Share GDSII reader logic and simplify review output

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.
This commit is contained in:
Jan Petykiewicz 2026-11-17 21:49:26 -08:00
commit 15e8a3b7b5

View file

@ -6,7 +6,7 @@ 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::{OResult, IResult, fail, parse_u16, take_bytes};
use crate::basic::{ErrType, IResult, OResult, fail, incomplete, take_bytes};
use crate::records;
@ -19,12 +19,15 @@ pub struct RecordHeader {
impl RecordHeader {
pub fn read(input: &[u8]) -> IResult<'_, RecordHeader> {
let (input, size) = parse_u16(input)?;
let (input, tag) = parse_u16(input)?;
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"));
};
Ok((input, RecordHeader{tag, data_size}))
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]> {
@ -43,6 +46,39 @@ impl RecordHeader {
}
/// 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;
@ -91,25 +127,28 @@ pub trait Record<RData: RecordData> {
///
fn skip_past(input: &[u8]) -> IResult<'_, bool> {
let original_input = input;
let (mut input, mut header) = RecordHeader::read(input)?;
while header.tag != Self::tag() {
(input, _) = take_bytes(input, header.data_size)?;
if header.tag == records::RTAG_ENDLIB {
return Ok((original_input, false))
let mut input = input;
loop {
let (remaining, record) = RecordFrame::read(input)?;
if record.tag == Self::tag() {
return Ok((remaining, true));
}
(input, header) = RecordHeader::read(input)?;
if record.tag == records::RTAG_ENDLIB {
return Ok((original_input, false));
}
input = remaining;
}
(input, _) = take_bytes(input, header.data_size)?;
Ok((input, true))
}
fn skip_and_read(input: &[u8]) -> IResult<'_, RData::BareData<'_>> {
let (mut input, mut header) = RecordHeader::read(input)?;
while header.tag != Self::tag() {
(input, _) = take_bytes(input, header.data_size)?;
(input, header) = RecordHeader::read(input)?;
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;
}
Self::read_data(input, header.data_size)
}
fn expect_header(input: &[u8]) -> IResult<'_, u16> {
@ -122,8 +161,10 @@ pub trait Record<RData: RecordData> {
}
fn read(input: &[u8]) -> IResult<'_, RData::BareData<'_>> {
let (input, size) = Self::expect_header(input)?;
Self::read_data(input, size)
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 {