Share record framing, name decoding, payload validation, array reference decoding, and Arrow cell-header parsing. Accept trailing NUL padding in names and retain located diagnostics for malformed records. Summarize text diffs by cell, layer, and reference target. Show comparison and omission counts before detail. Compact canonical dumps while preserving exact fields and duplicate counts for Git textconv. Simplify hierarchy output and retain per-object evidence in JSON.
466 lines
13 KiB
Rust
466 lines
13 KiB
Rust
///
|
|
/// Generic record-level read/write functionality.
|
|
///
|
|
use std::io::{self, Write};
|
|
|
|
|
|
use crate::basic::{pack_datetime, pack_bitarray, pack_ascii, pack_int2, pack_int4, pack_real8};
|
|
use crate::basic::{parse_datetime, parse_bitarray, parse_ascii, parse_int2, parse_int4, parse_real8};
|
|
use crate::basic::{ErrType, IResult, OResult, fail, incomplete, take_bytes};
|
|
use crate::records;
|
|
|
|
|
|
#[repr(C)]
|
|
#[derive(Debug, Clone)]
|
|
pub struct RecordHeader {
|
|
pub tag: u16,
|
|
pub data_size: u16,
|
|
}
|
|
|
|
impl RecordHeader {
|
|
pub fn read(input: &[u8]) -> IResult<'_, RecordHeader> {
|
|
let Some((&[size_hi, size_lo, tag_hi, tag_lo], payload)) = input.split_first_chunk::<4>() else {
|
|
return incomplete(input, Some(4));
|
|
};
|
|
let size = u16::from_be_bytes([size_hi, size_lo]);
|
|
let Some(data_size) = size.checked_sub(4) else {
|
|
return fail(input, format!("Record size {size} is smaller than its header"));
|
|
};
|
|
let tag = u16::from_be_bytes([tag_hi, tag_lo]);
|
|
Ok((payload, RecordHeader { tag, data_size }))
|
|
}
|
|
|
|
pub fn pack_into(&self) -> io::Result<[u8; 4]> {
|
|
let size = self.data_size.checked_add(4)
|
|
.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "Record longer than max size (u16)"))?;
|
|
let [size_hi, size_lo] = size.to_be_bytes();
|
|
let [tag_hi, tag_lo] = self.tag.to_be_bytes();
|
|
Ok([size_hi, size_lo, tag_hi, tag_lo])
|
|
}
|
|
|
|
pub fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
|
let bytes = self.pack_into()?;
|
|
ww.write_all(&bytes)?;
|
|
Ok(bytes.len())
|
|
}
|
|
}
|
|
|
|
|
|
/// A complete record borrowing its payload from the input.
|
|
pub(crate) struct RecordFrame<'a> {
|
|
pub tag: u16,
|
|
pub data: &'a [u8],
|
|
}
|
|
|
|
impl<'a> RecordFrame<'a> {
|
|
pub fn read(input: &'a [u8]) -> IResult<'a, Self> {
|
|
let (_, header) = RecordHeader::read(input)?;
|
|
let (remaining, data) = read_payload(input, header.data_size)?;
|
|
Ok((remaining, Self { tag: header.tag, data }))
|
|
}
|
|
|
|
/// Decode the payload after the caller has matched the record tag.
|
|
pub fn decode<R: Record<D> + ?Sized, D: RecordData>(
|
|
&self,
|
|
) -> Result<D::BareData<'a>, (&'a [u8], ErrType)> {
|
|
let (_, value) = R::read_data(self.data, self.data.len() as u16)?;
|
|
Ok(value)
|
|
}
|
|
}
|
|
|
|
fn read_payload(input: &[u8], size: u16) -> IResult<'_, &[u8]> {
|
|
if !size.is_multiple_of(2) {
|
|
return fail(input, "odd record length".to_string());
|
|
}
|
|
let Some((record, remaining)) = input.split_at_checked(4 + usize::from(size)) else {
|
|
return fail(input, "truncated record".to_string());
|
|
};
|
|
Ok((remaining, &record[4..]))
|
|
}
|
|
|
|
|
|
pub trait RecordData {
|
|
type BareData<'a>;
|
|
type InData : ?Sized;
|
|
type ByteData : AsRef<[u8]>;
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<'_, Self::BareData<'_>>;
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData);
|
|
fn pack(data: &Self::InData) -> Self::ByteData;
|
|
}
|
|
|
|
|
|
pub trait Record<RData: RecordData> {
|
|
fn tag() -> u16;
|
|
fn expected_size() -> Option<u16>;
|
|
|
|
fn check_size(actual_size: u16) -> Result<(), String> {
|
|
match Self::expected_size() {
|
|
Some(size) => if size == actual_size {
|
|
Ok(())
|
|
} else {
|
|
Err(format!("Expected record size {}, got {}", size, actual_size))
|
|
},
|
|
None => Ok(()),
|
|
}
|
|
}
|
|
|
|
fn write_header<W: Write>(ww: &mut W, data_size: u16) -> OResult {
|
|
Self::check_size(data_size)
|
|
.map_err(|message| io::Error::new(io::ErrorKind::InvalidInput, message))?;
|
|
RecordHeader{tag: Self::tag(), data_size}.write(ww)
|
|
}
|
|
|
|
fn read_data(input: &[u8], size: u16) -> IResult<'_, RData::BareData<'_>> {
|
|
if let Err(message) = Self::check_size(size) {
|
|
return fail(input, message);
|
|
}
|
|
RData::read(input, size)
|
|
}
|
|
|
|
///
|
|
/// Skip to the end of the next occurence of this record.
|
|
///
|
|
/// Return:
|
|
/// True if the record was encountered and skipped.
|
|
/// False if the end of the library was reached.
|
|
///
|
|
fn skip_past(input: &[u8]) -> IResult<'_, bool> {
|
|
let original_input = input;
|
|
let mut input = input;
|
|
loop {
|
|
let (remaining, record) = RecordFrame::read(input)?;
|
|
if record.tag == Self::tag() {
|
|
return Ok((remaining, true));
|
|
}
|
|
if record.tag == records::RTAG_ENDLIB {
|
|
return Ok((original_input, false));
|
|
}
|
|
input = remaining;
|
|
}
|
|
}
|
|
|
|
fn skip_and_read(input: &[u8]) -> IResult<'_, RData::BareData<'_>> {
|
|
let mut input = input;
|
|
loop {
|
|
let (remaining, record) = RecordFrame::read(input)?;
|
|
if record.tag == Self::tag() {
|
|
return Ok((remaining, record.decode::<Self, RData>()?));
|
|
}
|
|
input = remaining;
|
|
}
|
|
}
|
|
|
|
fn expect_header(input: &[u8]) -> IResult<'_, u16> {
|
|
let (input, header) = RecordHeader::read(input)?;
|
|
if header.tag != Self::tag() {
|
|
fail(input, format!("Unexpected record! Got tag 0x{:04x}, expected 0x{:04x}", header.tag, Self::tag()))
|
|
} else {
|
|
Ok((input, header.data_size))
|
|
}
|
|
}
|
|
|
|
fn read(input: &[u8]) -> IResult<'_, RData::BareData<'_>> {
|
|
let (_, size) = Self::expect_header(input)?;
|
|
let (remaining, data) = read_payload(input, size)?;
|
|
let (_, value) = Self::read_data(data, size)?;
|
|
Ok((remaining, value))
|
|
}
|
|
|
|
fn write<W: Write>(ww: &mut W, data: &RData::InData) -> OResult {
|
|
let packed_data = RData::pack(data);
|
|
let data_bytes = packed_data.as_ref();
|
|
let len = u16::try_from(data_bytes.len())
|
|
.map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "Record longer than max size (u16)"))?;
|
|
Self::write_header(ww, len)?;
|
|
ww.write_all(data_bytes)?;
|
|
Ok(usize::from(len) + 4)
|
|
}
|
|
}
|
|
|
|
pub struct BitArray;
|
|
impl RecordData for BitArray {
|
|
type BareData<'a> = [bool; 16];
|
|
type InData = [bool; 16];
|
|
type ByteData = [u8; 2];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<'_, Self::BareData<'_>> {
|
|
if size != 2 {
|
|
return fail(input, format!("Expected record size {}, got {size}", 2));
|
|
}
|
|
parse_bitarray(input)
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_bitarray(buf, data);
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = [0; 2];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
|
|
pub struct Int2;
|
|
impl RecordData for Int2 {
|
|
type BareData<'a> = i16;
|
|
type InData = i16;
|
|
type ByteData = [u8; 2];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<'_, Self::BareData<'_>> {
|
|
if size != 2 {
|
|
return fail(input, format!("Expected record size {}, got {size}", 2));
|
|
}
|
|
parse_int2(input)
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_int2(buf, *data)
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = [0; 2];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
pub struct Int4;
|
|
impl RecordData for Int4 {
|
|
type BareData<'a> = i32;
|
|
type InData = i32;
|
|
type ByteData = [u8; 4];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<'_, Self::BareData<'_>> {
|
|
if size != 4 {
|
|
return fail(input, format!("Expected record size {}, got {size}", 4));
|
|
}
|
|
parse_int4(input)
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_int4(buf, *data)
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = [0; 4];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
|
|
pub struct Int2Array;
|
|
impl RecordData for Int2Array {
|
|
type BareData<'a> = Int2ArrayReader<'a>;
|
|
type InData = [i16];
|
|
type ByteData = Vec<u8>;
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<'_, Self::BareData<'_>> {
|
|
if !size.is_multiple_of(2) {
|
|
return fail(input, format!("Record size must be divisible by 2, got {size}"));
|
|
}
|
|
let (input, bytes) = take_bytes(input, size)?;
|
|
Ok((input, Int2ArrayReader{bytes}))
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
assert_eq!(buf.len(), data.len() * 2);
|
|
for (bytes, value) in buf.as_chunks_mut::<2>().0.iter_mut().zip(data) {
|
|
*bytes = value.to_be_bytes();
|
|
}
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = vec![0; data.len() * 2];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
pub struct Int2ArrayReader<'a> {
|
|
bytes: &'a [u8],
|
|
}
|
|
impl Iterator for Int2ArrayReader<'_> {
|
|
type Item = i16;
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
if self.bytes.len() < 2 {
|
|
None
|
|
} else {
|
|
let (remaining, val) = parse_int2(self.bytes).unwrap();
|
|
self.bytes = remaining;
|
|
Some(val)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct Int4Array;
|
|
impl RecordData for Int4Array {
|
|
type BareData<'a> = Int4ArrayReader<'a>;
|
|
type InData = [i32];
|
|
type ByteData = Vec<u8>;
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<'_, Self::BareData<'_>> {
|
|
if !size.is_multiple_of(4) {
|
|
return fail(input, format!("Record size must be divisible by 4, got {size}"));
|
|
}
|
|
let (input, bytes) = take_bytes(input, size)?;
|
|
Ok((input, Int4ArrayReader{bytes}))
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
assert_eq!(buf.len(), data.len() * 4);
|
|
for (bytes, value) in buf.as_chunks_mut::<4>().0.iter_mut().zip(data) {
|
|
*bytes = value.to_be_bytes();
|
|
}
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = vec![0; data.len() * 4];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
pub struct Int4ArrayReader<'a> {
|
|
bytes: &'a [u8],
|
|
}
|
|
impl Iterator for Int4ArrayReader<'_> {
|
|
type Item = i32;
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
if self.bytes.len() < 4 {
|
|
None
|
|
} else {
|
|
let (remaining, val) = parse_int4(self.bytes).unwrap();
|
|
self.bytes = remaining;
|
|
Some(val)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct Real8;
|
|
impl RecordData for Real8 {
|
|
type BareData<'a> = f64;
|
|
type InData = f64;
|
|
type ByteData = [u8; 8];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<'_, Self::BareData<'_>> {
|
|
if size != 8 {
|
|
return fail(input, format!("Expected record size {}, got {size}", 8));
|
|
}
|
|
parse_real8(input)
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_real8(buf, *data).unwrap_or_else(|_| panic!("Float {0} too big for Real8", data))
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = [0; 8];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
pub struct Real8Pair;
|
|
impl RecordData for Real8Pair {
|
|
type BareData<'a> = (f64, f64);
|
|
type InData = (f64, f64);
|
|
type ByteData = [u8; 2 * 8];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<'_, Self::BareData<'_>> {
|
|
if size != 2 * 8 {
|
|
return fail(input, format!("Expected record size {}, got {size}", 2 * 8));
|
|
}
|
|
let (input, data0) = parse_real8(input)?;
|
|
let (input, data1) = parse_real8(input)?;
|
|
Ok((input, (data0, data1)))
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_real8(buf, data.0).unwrap_or_else(|_| panic!("Float.0 {0} too big for Real8", data.0));
|
|
pack_real8(&mut buf[8 * 1..], data.1).unwrap_or_else(|_| panic!("Float.1 {0} too big for Real8", data.1));
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = [0; 2 * 8];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
|
|
}
|
|
|
|
pub struct ASCII;
|
|
impl RecordData for ASCII {
|
|
type BareData<'a> = Vec<u8>;
|
|
type InData = [u8];
|
|
type ByteData = Vec<u8>;
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<'_, Self::BareData<'_>> {
|
|
parse_ascii(input, size)
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_ascii(buf, data);
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = vec![0; data.len() + data.len() % 2];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
|
|
pub struct DateTimePair;
|
|
impl RecordData for DateTimePair {
|
|
type BareData<'a> = [[i16; 6]; 2];
|
|
type InData = [[i16; 6]; 2];
|
|
type ByteData = [u8; 2 * 6 * 2];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<'_, Self::BareData<'_>> {
|
|
if size != 2 * 6 * 2 {
|
|
return fail(input, format!("Expected record size {}, got {size}", 2 * 6 * 2));
|
|
}
|
|
let (input, data0) = parse_datetime(input)?;
|
|
let (input, data1) = parse_datetime(input)?;
|
|
Ok((input, [data0, data1]))
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_datetime(buf, &data[0]);
|
|
pack_datetime(&mut buf[6 * 2 * 1..], &data[1]);
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = [0; 2 * 6 * 2];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
|
|
}
|
|
|
|
pub struct Empty;
|
|
impl RecordData for Empty {
|
|
type BareData<'a> = ();
|
|
type InData = ();
|
|
type ByteData = [u8; 0];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<'_, Self::BareData<'_>> {
|
|
if size != 0 {
|
|
return fail(input, format!("Expected record size {}, got {size}", 0));
|
|
}
|
|
Ok((input, ()))
|
|
}
|
|
|
|
fn pack_into(_buf: &mut [u8], _data: &Self::InData) {
|
|
}
|
|
|
|
fn pack(_data: &Self::InData) -> Self::ByteData {
|
|
[]
|
|
}
|
|
}
|