#[allow(dead_code)]
pub const PR_NO_ERR: i16 = 0;
pub const PR_OP_NOT_IMPL: i16 = 2;
pub const PR_ROUTINE_OPEN_DOC: u8 = 0x04;
pub const PR_ROUTINE_CLOSE_DOC: u8 = 0x08;
pub const PR_ROUTINE_OPEN_PAGE: u8 = 0x10;
pub const PR_ROUTINE_CLOSE_PAGE: u8 = 0x18;
pub const PR_ROUTINE_PRINT_DEFAULT: u8 = 0x20;
pub const PR_ROUTINE_STL_DIALOG: u8 = 0x2A;
pub const PR_ROUTINE_JOB_DIALOG: u8 = 0x32;
pub const PR_ROUTINE_STL_INIT: u8 = 0x3C;
pub const PR_ROUTINE_JOB_INIT: u8 = 0x44;
pub const PR_ROUTINE_DLG_MAIN: u8 = 0x4A;
pub const PR_ROUTINE_VALIDATE: u8 = 0x52;
pub const PR_ROUTINE_JOB_MERGE: u8 = 0x58;
pub const PR_ROUTINE_PIC_FILE: u8 = 0x60;
pub const PR_ROUTINE_GENERAL: u8 = 0x70;
pub const PR_ROUTINE_DRVR_OPEN: u8 = 0x80;
pub const PR_ROUTINE_DRVR_CLOSE: u8 = 0x88;
pub const PR_ROUTINE_DRVR_DCE: u8 = 0x94;
pub const PR_ROUTINE_DRVR_VERS: u8 = 0x9A;
pub const PR_ROUTINE_CTL_CALL: u8 = 0xA0;
pub const PR_ROUTINE_ERROR: u8 = 0xBA;
pub const PR_ROUTINE_SET_ERROR: u8 = 0xC0;
pub const PR_ROUTINE_OPEN: u8 = 0xC8;
pub const PR_ROUTINE_CLOSE: u8 = 0xD0;
#[allow(dead_code)]
pub const PR_OPEN_DOC_SELECTOR: u32 = 0x0400_0C00;
#[allow(dead_code)]
pub const PR_CLOSE_DOC_SELECTOR: u32 = 0x0800_0484;
#[allow(dead_code)]
pub const PR_OPEN_PAGE_SELECTOR: u32 = 0x1000_0808;
#[allow(dead_code)]
pub const PR_CLOSE_PAGE_SELECTOR: u32 = 0x1800_040C;
#[allow(dead_code)]
pub const PR_PRINT_DEFAULT_SELECTOR: u32 = 0x2004_0480;
#[allow(dead_code)]
pub const PR_STL_DIALOG_SELECTOR: u32 = 0x2A04_0484;
#[allow(dead_code)]
pub const PR_JOB_DIALOG_SELECTOR: u32 = 0x3204_0488;
#[allow(dead_code)]
pub const PR_STL_INIT_SELECTOR: u32 = 0x3C04_040C;
#[allow(dead_code)]
pub const PR_JOB_INIT_SELECTOR: u32 = 0x4404_0410;
#[allow(dead_code)]
pub const PR_DLG_MAIN_SELECTOR: u32 = 0x4A04_0894;
#[allow(dead_code)]
pub const PR_VALIDATE_SELECTOR: u32 = 0x5204_0498;
#[allow(dead_code)]
pub const PR_JOB_MERGE_SELECTOR: u32 = 0x5804_089C;
#[allow(dead_code)]
pub const PR_PIC_FILE_SELECTOR: u32 = 0x6005_1480;
#[allow(dead_code)]
pub const PR_GENERAL_SELECTOR: u32 = 0x7007_0480;
#[allow(dead_code)]
pub const PR_DRVR_OPEN_SELECTOR: u32 = 0x8000_0000;
#[allow(dead_code)]
pub const PR_DRVR_CLOSE_SELECTOR: u32 = 0x8800_0000;
#[allow(dead_code)]
pub const PR_DRVR_DCE_SELECTOR: u32 = 0x9400_0000;
#[allow(dead_code)]
pub const PR_DRVR_VERS_SELECTOR: u32 = 0x9A00_0000;
#[allow(dead_code)]
pub const PR_CTL_CALL_SELECTOR: u32 = 0xA000_0E00;
#[allow(dead_code)]
pub const PR_ERROR_SELECTOR: u32 = 0xBA00_0000;
#[allow(dead_code)]
pub const PR_SET_ERROR_SELECTOR: u32 = 0xC000_0200;
#[allow(dead_code)]
pub const PR_OPEN_SELECTOR: u32 = 0xC800_0000;
#[allow(dead_code)]
pub const PR_CLOSE_SELECTOR: u32 = 0xD000_0000;
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PrintingArchitecture {
M68k,
PowerPc,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum PrintingOperation {
OpenDoc,
CloseDoc,
OpenPage,
ClosePage,
PrintDefault,
StlDialog,
JobDialog,
StlInit,
JobInit,
DlgMain,
Validate,
JobMerge,
PicFile,
General,
DrvrOpen,
DrvrClose,
DrvrDce,
DrvrVers,
CtlCall,
Error,
SetError,
Open,
Close,
}
impl PrintingOperation {
#[inline]
pub const fn from_routine_byte(routine: u8) -> Option<Self> {
match routine {
PR_ROUTINE_OPEN_DOC => Some(Self::OpenDoc),
PR_ROUTINE_CLOSE_DOC => Some(Self::CloseDoc),
PR_ROUTINE_OPEN_PAGE => Some(Self::OpenPage),
PR_ROUTINE_CLOSE_PAGE => Some(Self::ClosePage),
PR_ROUTINE_PRINT_DEFAULT => Some(Self::PrintDefault),
PR_ROUTINE_STL_DIALOG => Some(Self::StlDialog),
PR_ROUTINE_JOB_DIALOG => Some(Self::JobDialog),
PR_ROUTINE_STL_INIT => Some(Self::StlInit),
PR_ROUTINE_JOB_INIT => Some(Self::JobInit),
PR_ROUTINE_DLG_MAIN => Some(Self::DlgMain),
PR_ROUTINE_VALIDATE => Some(Self::Validate),
PR_ROUTINE_JOB_MERGE => Some(Self::JobMerge),
PR_ROUTINE_PIC_FILE => Some(Self::PicFile),
PR_ROUTINE_GENERAL => Some(Self::General),
PR_ROUTINE_DRVR_OPEN => Some(Self::DrvrOpen),
PR_ROUTINE_DRVR_CLOSE => Some(Self::DrvrClose),
PR_ROUTINE_DRVR_DCE => Some(Self::DrvrDce),
PR_ROUTINE_DRVR_VERS => Some(Self::DrvrVers),
PR_ROUTINE_CTL_CALL => Some(Self::CtlCall),
PR_ROUTINE_ERROR => Some(Self::Error),
PR_ROUTINE_SET_ERROR => Some(Self::SetError),
PR_ROUTINE_OPEN => Some(Self::Open),
PR_ROUTINE_CLOSE => Some(Self::Close),
_ => None,
}
}
#[allow(dead_code)]
#[inline]
pub const fn routine_byte(self) -> u8 {
match self {
Self::OpenDoc => PR_ROUTINE_OPEN_DOC,
Self::CloseDoc => PR_ROUTINE_CLOSE_DOC,
Self::OpenPage => PR_ROUTINE_OPEN_PAGE,
Self::ClosePage => PR_ROUTINE_CLOSE_PAGE,
Self::PrintDefault => PR_ROUTINE_PRINT_DEFAULT,
Self::StlDialog => PR_ROUTINE_STL_DIALOG,
Self::JobDialog => PR_ROUTINE_JOB_DIALOG,
Self::StlInit => PR_ROUTINE_STL_INIT,
Self::JobInit => PR_ROUTINE_JOB_INIT,
Self::DlgMain => PR_ROUTINE_DLG_MAIN,
Self::Validate => PR_ROUTINE_VALIDATE,
Self::JobMerge => PR_ROUTINE_JOB_MERGE,
Self::PicFile => PR_ROUTINE_PIC_FILE,
Self::General => PR_ROUTINE_GENERAL,
Self::DrvrOpen => PR_ROUTINE_DRVR_OPEN,
Self::DrvrClose => PR_ROUTINE_DRVR_CLOSE,
Self::DrvrDce => PR_ROUTINE_DRVR_DCE,
Self::DrvrVers => PR_ROUTINE_DRVR_VERS,
Self::CtlCall => PR_ROUTINE_CTL_CALL,
Self::Error => PR_ROUTINE_ERROR,
Self::SetError => PR_ROUTINE_SET_ERROR,
Self::Open => PR_ROUTINE_OPEN,
Self::Close => PR_ROUTINE_CLOSE,
}
}
#[allow(dead_code)]
#[inline]
pub const fn name(self) -> &'static str {
match self {
Self::OpenDoc => "PrOpenDoc",
Self::CloseDoc => "PrCloseDoc",
Self::OpenPage => "PrOpenPage",
Self::ClosePage => "PrClosePage",
Self::PrintDefault => "PrintDefault",
Self::StlDialog => "PrStlDialog",
Self::JobDialog => "PrJobDialog",
Self::StlInit => "PrStlInit",
Self::JobInit => "PrJobInit",
Self::DlgMain => "PrDlgMain",
Self::Validate => "PrValidate",
Self::JobMerge => "PrJobMerge",
Self::PicFile => "PrPicFile",
Self::General => "PrGeneral",
Self::DrvrOpen => "PrDrvrOpen",
Self::DrvrClose => "PrDrvrClose",
Self::DrvrDce => "PrDrvrDCE",
Self::DrvrVers => "PrDrvrVers",
Self::CtlCall => "PrCtlCall",
Self::Error => "PrError",
Self::SetError => "PrSetError",
Self::Open => "PrOpen",
Self::Close => "PrClose",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PrGlueSelectorDecode {
pub routine: u8,
pub param_bytes: u32,
pub total_pop: u32,
pub operation: Option<PrintingOperation>,
}
#[inline]
pub fn decode_pr_glue_selector(selector: u32) -> PrGlueSelectorDecode {
let routine = ((selector >> 24) & 0xFF) as u8;
let param_bytes = (selector >> 8) & 0xFF;
let total_pop = 4 + param_bytes;
let operation = PrintingOperation::from_routine_byte(routine);
PrGlueSelectorDecode {
routine,
param_bytes,
total_pop,
operation,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PrGlueStackResult {
None,
Word(u16),
Long(u32),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PrGlueRegisterResult {
Preserve,
Set(u32),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PrGlueErrorAction {
Preserve,
Reset,
Set(i16),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PrGlueEvaluation {
pub routine: u8,
pub param_bytes: u32,
pub total_pop: u32,
pub operation: Option<PrintingOperation>,
pub stack_result: PrGlueStackResult,
pub register_result: PrGlueRegisterResult,
pub error_action: PrGlueErrorAction,
}
#[inline]
pub fn evaluate_pr_glue(
selector: u32,
current_printing_error: i16,
set_error_arg: i16,
) -> PrGlueEvaluation {
let decoded = decode_pr_glue_selector(selector);
let (stack_result, register_result, error_action) = match decoded.routine {
PR_ROUTINE_OPEN_DOC => (
PrGlueStackResult::Long(0),
PrGlueRegisterResult::Set(0),
PrGlueErrorAction::Reset,
),
PR_ROUTINE_CLOSE_DOC | PR_ROUTINE_OPEN_PAGE | PR_ROUTINE_CLOSE_PAGE => (
PrGlueStackResult::None,
PrGlueRegisterResult::Preserve,
PrGlueErrorAction::Reset,
),
PR_ROUTINE_PRINT_DEFAULT => (
PrGlueStackResult::None,
PrGlueRegisterResult::Set(0),
PrGlueErrorAction::Reset,
),
PR_ROUTINE_OPEN | PR_ROUTINE_CLOSE => (
PrGlueStackResult::None,
PrGlueRegisterResult::Preserve,
PrGlueErrorAction::Preserve,
),
PR_ROUTINE_STL_DIALOG | PR_ROUTINE_JOB_DIALOG => (
PrGlueStackResult::Word(1),
PrGlueRegisterResult::Set(1),
PrGlueErrorAction::Reset,
),
PR_ROUTINE_STL_INIT | PR_ROUTINE_JOB_INIT => (
PrGlueStackResult::Long(0),
PrGlueRegisterResult::Set(0),
PrGlueErrorAction::Reset,
),
PR_ROUTINE_DLG_MAIN => (
PrGlueStackResult::Word(1),
PrGlueRegisterResult::Set(1),
PrGlueErrorAction::Reset,
),
PR_ROUTINE_VALIDATE => (
PrGlueStackResult::Word(0),
PrGlueRegisterResult::Set(0),
PrGlueErrorAction::Reset,
),
PR_ROUTINE_JOB_MERGE
| PR_ROUTINE_PIC_FILE
| PR_ROUTINE_GENERAL
| PR_ROUTINE_DRVR_OPEN
| PR_ROUTINE_DRVR_CLOSE
| PR_ROUTINE_CTL_CALL => (
PrGlueStackResult::None,
PrGlueRegisterResult::Set(0),
PrGlueErrorAction::Reset,
),
PR_ROUTINE_DRVR_DCE => (
PrGlueStackResult::Long(0),
PrGlueRegisterResult::Set(0),
PrGlueErrorAction::Reset,
),
PR_ROUTINE_DRVR_VERS => (
PrGlueStackResult::Word(0),
PrGlueRegisterResult::Set(0),
PrGlueErrorAction::Reset,
),
PR_ROUTINE_ERROR => (
PrGlueStackResult::Word(current_printing_error as u16),
PrGlueRegisterResult::Set(current_printing_error as u32),
PrGlueErrorAction::Preserve,
),
PR_ROUTINE_SET_ERROR => (
PrGlueStackResult::None,
PrGlueRegisterResult::Set(0),
PrGlueErrorAction::Set(set_error_arg),
),
_ => (
PrGlueStackResult::None,
PrGlueRegisterResult::Set(0),
PrGlueErrorAction::Reset,
),
};
PrGlueEvaluation {
routine: decoded.routine,
param_bytes: decoded.param_bytes,
total_pop: decoded.total_pop,
operation: decoded.operation,
stack_result,
register_result,
error_action,
}
}
#[inline]
pub fn evaluate_pr_set_error(input_err: i16) -> i16 {
input_err
}
#[inline]
pub fn evaluate_pr_error(current_err: i16) -> i16 {
current_err
}
#[inline]
pub fn evaluate_pr_validate() -> bool {
false
}
#[inline]
pub const fn evaluate_print_default() -> u32 {
0
}
#[inline]
pub const fn evaluate_pr_open_doc() -> u32 {
0
}
#[inline]
pub fn evaluate_pr_dialog(arch: PrintingArchitecture) -> bool {
match arch {
PrintingArchitecture::M68k => true,
PrintingArchitecture::PowerPc => false,
}
}
#[inline]
pub fn evaluate_pr_general(memory_writable: bool) -> Option<i16> {
if memory_writable {
Some(PR_OP_NOT_IMPL)
} else {
None
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pr_glue_selector_decoding() {
let open_doc = decode_pr_glue_selector(PR_OPEN_DOC_SELECTOR);
assert_eq!(open_doc.routine, PR_ROUTINE_OPEN_DOC);
assert_eq!(open_doc.param_bytes, 12);
assert_eq!(open_doc.total_pop, 16);
assert_eq!(open_doc.operation, Some(PrintingOperation::OpenDoc));
let print_default = decode_pr_glue_selector(PR_PRINT_DEFAULT_SELECTOR);
assert_eq!(print_default.routine, PR_ROUTINE_PRINT_DEFAULT);
assert_eq!(print_default.param_bytes, 4);
assert_eq!(print_default.total_pop, 8);
assert_eq!(
print_default.operation,
Some(PrintingOperation::PrintDefault)
);
let open = decode_pr_glue_selector(PR_OPEN_SELECTOR);
assert_eq!(open.routine, PR_ROUTINE_OPEN);
assert_eq!(open.param_bytes, 0);
assert_eq!(open.total_pop, 4);
assert_eq!(open.operation, Some(PrintingOperation::Open));
let set_error = decode_pr_glue_selector(PR_SET_ERROR_SELECTOR);
assert_eq!(set_error.routine, PR_ROUTINE_SET_ERROR);
assert_eq!(set_error.param_bytes, 2);
assert_eq!(set_error.total_pop, 6);
assert_eq!(set_error.operation, Some(PrintingOperation::SetError));
let custom = decode_pr_glue_selector(0xF100_0600);
assert_eq!(custom.routine, 0xF1);
assert_eq!(custom.param_bytes, 6);
assert_eq!(custom.total_pop, 10);
assert_eq!(custom.operation, None);
}
#[test]
fn pr_glue_evaluation_stack_and_register_contracts() {
let eval_open_doc = evaluate_pr_glue(PR_OPEN_DOC_SELECTOR, -128, 0);
assert_eq!(eval_open_doc.stack_result, PrGlueStackResult::Long(0));
assert_eq!(eval_open_doc.register_result, PrGlueRegisterResult::Set(0));
assert_eq!(eval_open_doc.error_action, PrGlueErrorAction::Reset);
let eval_close_doc = evaluate_pr_glue(PR_CLOSE_DOC_SELECTOR, -128, 0);
assert_eq!(eval_close_doc.stack_result, PrGlueStackResult::None);
assert_eq!(
eval_close_doc.register_result,
PrGlueRegisterResult::Preserve
);
assert_eq!(eval_close_doc.error_action, PrGlueErrorAction::Reset);
let eval_open = evaluate_pr_glue(PR_OPEN_SELECTOR, 42, 0);
assert_eq!(eval_open.stack_result, PrGlueStackResult::None);
assert_eq!(eval_open.register_result, PrGlueRegisterResult::Preserve);
assert_eq!(eval_open.error_action, PrGlueErrorAction::Preserve);
let eval_close = evaluate_pr_glue(PR_CLOSE_SELECTOR, 42, 0);
assert_eq!(eval_close.stack_result, PrGlueStackResult::None);
assert_eq!(eval_close.register_result, PrGlueRegisterResult::Preserve);
assert_eq!(eval_close.error_action, PrGlueErrorAction::Preserve);
let eval_stl_dlg = evaluate_pr_glue(PR_STL_DIALOG_SELECTOR, 0, 0);
assert_eq!(eval_stl_dlg.stack_result, PrGlueStackResult::Word(1));
assert_eq!(eval_stl_dlg.register_result, PrGlueRegisterResult::Set(1));
assert_eq!(eval_stl_dlg.error_action, PrGlueErrorAction::Reset);
let eval_job_dlg = evaluate_pr_glue(PR_JOB_DIALOG_SELECTOR, 0, 0);
assert_eq!(eval_job_dlg.stack_result, PrGlueStackResult::Word(1));
assert_eq!(eval_job_dlg.register_result, PrGlueRegisterResult::Set(1));
assert_eq!(eval_job_dlg.error_action, PrGlueErrorAction::Reset);
let eval_validate = evaluate_pr_glue(PR_VALIDATE_SELECTOR, 0, 0);
assert_eq!(eval_validate.stack_result, PrGlueStackResult::Word(0));
assert_eq!(eval_validate.register_result, PrGlueRegisterResult::Set(0));
assert_eq!(eval_validate.error_action, PrGlueErrorAction::Reset);
let eval_error = evaluate_pr_glue(PR_ERROR_SELECTOR, -128, 0);
assert_eq!(
eval_error.stack_result,
PrGlueStackResult::Word((-128i16) as u16)
);
assert_eq!(
eval_error.register_result,
PrGlueRegisterResult::Set((-128i16) as u32)
);
assert_eq!(eval_error.error_action, PrGlueErrorAction::Preserve);
let eval_set_error = evaluate_pr_glue(PR_SET_ERROR_SELECTOR, 0, 0x1357);
assert_eq!(eval_set_error.stack_result, PrGlueStackResult::None);
assert_eq!(eval_set_error.register_result, PrGlueRegisterResult::Set(0));
assert_eq!(eval_set_error.error_action, PrGlueErrorAction::Set(0x1357));
}
#[test]
fn printing_operation_enum_mapping_roundtrip() {
for op in [
PrintingOperation::OpenDoc,
PrintingOperation::CloseDoc,
PrintingOperation::OpenPage,
PrintingOperation::ClosePage,
PrintingOperation::PrintDefault,
PrintingOperation::StlDialog,
PrintingOperation::JobDialog,
PrintingOperation::StlInit,
PrintingOperation::JobInit,
PrintingOperation::DlgMain,
PrintingOperation::Validate,
PrintingOperation::JobMerge,
PrintingOperation::PicFile,
PrintingOperation::General,
PrintingOperation::DrvrOpen,
PrintingOperation::DrvrClose,
PrintingOperation::DrvrDce,
PrintingOperation::DrvrVers,
PrintingOperation::CtlCall,
PrintingOperation::Error,
PrintingOperation::SetError,
PrintingOperation::Open,
PrintingOperation::Close,
] {
let byte = op.routine_byte();
let mapped = PrintingOperation::from_routine_byte(byte);
assert_eq!(mapped, Some(op));
assert!(!op.name().is_empty());
}
}
#[test]
fn printing_manager_evaluation_helpers() {
assert_eq!(evaluate_pr_error(42), 42);
assert_eq!(evaluate_pr_set_error(-128), -128);
assert!(!evaluate_pr_validate());
assert_eq!(evaluate_print_default(), 0);
assert_eq!(evaluate_pr_open_doc(), 0);
assert!(evaluate_pr_dialog(PrintingArchitecture::M68k));
assert!(!evaluate_pr_dialog(PrintingArchitecture::PowerPc));
assert_eq!(evaluate_pr_general(true), Some(PR_OP_NOT_IMPL));
assert_eq!(evaluate_pr_general(false), None);
}
}