use crate::le;
use crate::text::{self, StringEncoding, TextDecoder};
pub const STRING_LINKAGE: u16 = 0x56d2;
pub const DEPENDENCY_LINKAGE: u16 = 0x56d0;
pub const FILL_LINKAGE: u16 = 0x0041;
pub const ASSOC_ID_LINKAGE: u16 = 0x7d2f;
pub const CODEPAGE_LINKAGE: u16 = 0x80d4;
#[derive(Debug, Clone, PartialEq)]
pub enum LinkageData {
String {
string_id: u32,
text: String,
encoding: StringEncoding,
},
Dependency {
app_id: u16,
app_value: u16,
root_type: u8,
copy_option: u8,
roots: Vec<u64>,
},
Fill {
color: u32,
},
AssocId(u32),
Database {
entity: u32,
mslink: u32,
},
CodePage(u32),
Raw,
}
#[derive(Debug, Clone, PartialEq)]
pub struct Linkage {
pub offset: usize,
pub id: u16,
pub flags: u8,
pub data: LinkageData,
pub bytes: Vec<u8>,
}
pub(crate) fn parse(
attr: &[u8],
base: usize,
v8: bool,
enc: impl Into<TextDecoder>,
) -> Vec<Linkage> {
let enc = enc.into();
let mut out = Vec::new();
let mut off = 0usize;
while off < attr.len() {
let rest = attr.get(off..).unwrap_or(&[]);
if rest.iter().all(|&b| b == 0) {
if v8 || rest.len() < 8 {
break;
}
}
if rest.len() < 4 {
out.push(Linkage {
offset: base + off,
id: 0,
flags: 0,
data: LinkageData::Raw,
bytes: rest.to_vec(),
});
break;
}
let (b0, b1) = (
rest.first().copied().unwrap_or(0),
rest.get(1).copied().unwrap_or(0),
);
let dmrs = !v8 && b0 == 0 && (b1 == 0 || b1 == 0x80);
let size = if dmrs {
8
} else if b1 & 0x10 != 0 || v8 {
(usize::from(b0) + 1) * 2
} else {
0
};
let framed = if size >= 4 { rest.get(..size) } else { None };
let Some(bytes) = framed else {
out.push(Linkage {
offset: base + off,
id: 0,
flags: b1,
data: LinkageData::Raw,
bytes: rest.to_vec(),
});
break;
};
let id = if dmrs {
0
} else {
le::u16_at(bytes, 2).unwrap_or(0)
};
let data = if dmrs {
LinkageData::Database {
entity: u32::from(le::u16_at(bytes, 2).unwrap_or(0)),
mslink: u32::from_le_bytes([
le::u8_at(bytes, 4).unwrap_or(0),
le::u8_at(bytes, 5).unwrap_or(0),
le::u8_at(bytes, 6).unwrap_or(0),
0,
]),
}
} else {
decode(id, bytes, v8, enc)
};
out.push(Linkage {
offset: base + off,
id,
flags: b1,
data,
bytes: bytes.to_vec(),
});
off += size;
}
out
}
fn decode(id: u16, b: &[u8], v8: bool, enc: TextDecoder) -> LinkageData {
match id {
STRING_LINKAGE if v8 => {
let (Some(string_id), Some(len)) = (le::u32_at(b, 4), le::u32_at(b, 8)) else {
return LinkageData::Raw;
};
let len = usize::try_from(len).unwrap_or(usize::MAX);
let payload = b.get(12..).unwrap_or(&[]);
let payload = payload.get(..len.min(payload.len())).unwrap_or(&[]);
let (text, encoding) = text::decode_linkage_string(payload, enc);
LinkageData::String {
string_id,
text,
encoding,
}
}
DEPENDENCY_LINKAGE if v8 => {
let app_id = le::u16_at(b, 4).unwrap_or(0);
let app_value = le::u16_at(b, 6).unwrap_or(0);
let copy_option = le::u8_at(b, 8).unwrap_or(0);
let root_type = le::u8_at(b, 9).unwrap_or(0);
let count = usize::from(le::u16_at(b, 10).unwrap_or(0));
let (first, stride, skip) = match root_type {
2 | 3 => (12usize, 8usize, 0usize),
9 | 10 => (12, 16, 8),
_ => (0, 0, 0),
};
let roots = if stride == 0 {
Vec::new()
} else {
(0..count)
.map_while(|i| le::u64_at(b, first + i * stride + skip))
.take(b.len() / 8)
.collect()
};
LinkageData::Dependency {
app_id,
app_value,
root_type,
copy_option,
roots,
}
}
FILL_LINKAGE => {
let color = if v8 {
le::u32_at(b, 8)
} else {
le::u8_at(b, 8).map(u32::from)
};
color.map_or(LinkageData::Raw, |color| LinkageData::Fill { color })
}
ASSOC_ID_LINKAGE => le::u32_at(b, 4).map_or(LinkageData::Raw, LinkageData::AssocId),
CODEPAGE_LINKAGE if v8 => le::u32_at(b, 12)
.filter(|&cp| cp > 0 && cp < 65536)
.map_or(LinkageData::Raw, LinkageData::CodePage),
_ if b.len() == 16 && !v8 => LinkageData::Database {
entity: u32::from(le::u16_at(b, 6).unwrap_or(0)),
mslink: le::u32_at(b, 8).unwrap_or(0),
},
_ => LinkageData::Raw,
}
}
pub(crate) fn string(linkages: &[Linkage], string_id: u32) -> Option<String> {
linkages.iter().find_map(|l| match &l.data {
LinkageData::String {
string_id: id,
text,
..
} if *id == string_id => Some(text.clone()),
_ => None,
})
}
pub(crate) fn dependency_root(linkages: &[Linkage], app_id: u16) -> Option<u64> {
linkages.iter().find_map(|l| match &l.data {
LinkageData::Dependency {
app_id: a, roots, ..
} if *a == app_id => roots.first().copied(),
_ => None,
})
}
#[cfg(test)]
mod tests {
use super::*;
fn enc() -> &'static encoding_rs::Encoding {
encoding_rs::WINDOWS_1252
}
#[test]
fn parses_string_and_dependency_linkages() {
let mut a = vec![0x0b, 0x10, 0xd2, 0x56, 1, 0, 0, 0, 7, 0, 0, 0];
a.extend_from_slice(b"Default\0\0\0\0\0");
a.extend_from_slice(&[0x0b, 0x10, 0xd0, 0x56, 0x17, 0x27, 0, 0, 0, 2, 1, 0]);
a.extend_from_slice(&0x6e_u64.to_le_bytes());
a.extend_from_slice(&[0; 4]);
let mut d = vec![0x1b, 0x10, 0xd0, 0x56, 0x10, 0x27, 1, 0, 0, 10, 1, 0];
d.extend_from_slice(&7u64.to_le_bytes());
d.extend_from_slice(&0x6b_u64.to_le_bytes());
d.resize(56, 0);
a.extend_from_slice(&d);
a.extend_from_slice(&[0; 6]); let l = parse(&a, 100, true, enc());
assert_eq!(l.len(), 3);
assert_eq!(l[0].offset, 100);
assert_eq!(string(&l, 1).as_deref(), Some("Default"));
assert_eq!(dependency_root(&l, 0x2717), Some(0x6e));
assert_eq!(dependency_root(&l, 0x2710), Some(0x6b));
}
#[test]
fn v7_dmrs_fill_and_garbage() {
let a = [
0x00, 0x00, 0x05, 0x00, 0x01, 0x02, 0x03, 0x00, 0x07, 0x10, 0x41, 0x00, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0x03, 0x00, 0xff, ];
let l = parse(&a, 0, false, enc());
assert_eq!(
l[0].data,
LinkageData::Database {
entity: 5,
mslink: 0x030201
}
);
assert_eq!(l[1].data, LinkageData::Fill { color: 9 });
assert_eq!(l[2].data, LinkageData::Raw);
let l = parse(&[0xff, 0x10, 0xd2, 0x56, 1], 0, true, enc());
assert_eq!(l.len(), 1);
assert_eq!(l[0].data, LinkageData::Raw);
}
}