use crate::{SAT_ACIS_BINARY, SAT_ASM_BINARY, SAT_TEXT};
use cadmpeg_asm::kernel_header::{BinaryHeader, KernelHeader};
use cadmpeg_asm::{acis_header, asm_header, sat};
use cadmpeg_core::dialect::{DialectId, DialectMatch};
use cadmpeg_ir::report::loss::LossNote;
use std::collections::BTreeMap;
use crate::loss::SatLossCode;
const DECLARED_ENCODING: &str = "encoding";
const DECLARED_TERMINATOR: &str = "terminator";
pub(crate) struct TextEvidence<'a> {
pub(crate) branch: sat::Terminator,
pub(crate) header: &'a KernelHeader,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Family {
Asm,
Acis,
}
impl Family {
pub(crate) const fn as_str(self) -> &'static str {
match self {
Self::Asm => "asm",
Self::Acis => "acis",
}
}
}
impl From<sat::Terminator> for Family {
fn from(value: sat::Terminator) -> Self {
match value {
sat::Terminator::Asm => Self::Asm,
sat::Terminator::Acis => Self::Acis,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct RecordStreamStart(usize);
impl RecordStreamStart {
pub(crate) const fn offset(self) -> usize {
self.0
}
}
pub(crate) fn record_stream_start(
bytes: &[u8],
family: Family,
header: &BinaryHeader,
) -> Option<RecordStreamStart> {
let start = match family {
Family::Asm => asm_header::record_stream_start_with_header(bytes, header),
Family::Acis => acis_header::record_stream_start_with_header(bytes, header),
}?;
Some(RecordStreamStart(start))
}
pub(crate) enum StreamEvidence<'a> {
Binary {
family: Family,
header: &'a BinaryHeader,
stream: Option<RecordStreamStart>,
},
Text(Option<TextEvidence<'a>>),
}
impl StreamEvidence<'_> {
const fn dialect(&self) -> DialectId {
match self {
Self::Binary {
family: Family::Asm,
..
} => SAT_ASM_BINARY,
Self::Binary {
family: Family::Acis,
..
} => SAT_ACIS_BINARY,
Self::Text(_) => SAT_TEXT,
}
}
}
fn host(evidence: &StreamEvidence<'_>) -> DialectMatch {
let dialect = evidence.dialect();
match evidence {
StreamEvidence::Binary {
stream: Some(_), ..
}
| StreamEvidence::Text(Some(_)) => DialectMatch::admitted(dialect),
StreamEvidence::Binary { stream: None, .. } | StreamEvidence::Text(None) => {
DialectMatch::refused(dialect)
}
}
}
pub(crate) fn dialect_loss(matched: &DialectMatch) -> Option<LossNote> {
cadmpeg_asm::dialect::unverified_message("the stream", matched)
.map(|message| SatLossCode::SourceDialectUnverified.note(message))
}
fn declared(evidence: &StreamEvidence<'_>) -> BTreeMap<cadmpeg_core::text::NonBlankString, String> {
let mut declared = BTreeMap::new();
match evidence {
StreamEvidence::Binary { .. } => {
declared.insert(
cadmpeg_core::nonblank_const!(DECLARED_ENCODING),
"binary".into(),
);
}
StreamEvidence::Text(text) => {
declared.insert(
cadmpeg_core::nonblank_const!(DECLARED_ENCODING),
"text".into(),
);
let Some(text) = text else { return declared };
declared.insert(
cadmpeg_core::nonblank_const!(DECLARED_TERMINATOR),
terminator_line(text.branch).into(),
);
}
}
declared
}
pub(crate) const fn terminator_line(branch: sat::Terminator) -> &'static str {
match branch {
sat::Terminator::Asm => "End-of-ASM-data",
sat::Terminator::Acis => "End-of-ACIS-data",
}
}
fn classify(evidence: &StreamEvidence<'_>) -> DialectMatch {
host(evidence).with_declared(declared(evidence))
}
fn kernel_layer(evidence: &StreamEvidence<'_>) -> DialectMatch {
let header = match evidence {
StreamEvidence::Binary { family, header, .. } => match family {
Family::Asm => cadmpeg_asm::dialect::KernelHeaderRef::Asm(header),
Family::Acis => cadmpeg_asm::dialect::KernelHeaderRef::Acis(header),
},
StreamEvidence::Text(Some(text)) => match text.branch {
sat::Terminator::Asm => cadmpeg_asm::dialect::KernelHeaderRef::TextAsm(text.header),
sat::Terminator::Acis => cadmpeg_asm::dialect::KernelHeaderRef::TextAcis(text.header),
},
StreamEvidence::Text(None) => cadmpeg_asm::dialect::KernelHeaderRef::Unknown,
};
cadmpeg_asm::dialect::classify(header)
}
pub(crate) fn layers(evidence: &StreamEvidence<'_>) -> (DialectMatch, DialectMatch) {
(classify(evidence), kernel_layer(evidence))
}
#[cfg(test)]
mod tests;