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.
605 lines
21 KiB
Rust
605 lines
21 KiB
Rust
///
|
|
/// File-level read/write functionality.
|
|
///
|
|
|
|
use std::io::Write;
|
|
|
|
use crate::record::{Record, RecordFrame};
|
|
use crate::records;
|
|
use crate::elements::{read_elements, scan_elements, DListBuilder, FListBuilder, ScanRefRecord};
|
|
use crate::basic::{ErrType, IResult, OResult, decode_name, fail};
|
|
|
|
use std::string::String;
|
|
use std::collections::HashMap;
|
|
use std::sync::Arc;
|
|
|
|
use arrow_schema::{DataType, Field, Fields};
|
|
use arrow_array::{
|
|
StructArray,
|
|
builder::{
|
|
BooleanBuilder, Float64Builder, Int16Builder, StringBuilder, StructBuilder,
|
|
UInt32Builder, UInt64Builder,
|
|
},
|
|
};
|
|
|
|
|
|
///
|
|
/// Representation of the GDS file header.
|
|
///
|
|
/// File header records: HEADER BGNLIB LIBNAME UNITS
|
|
/// Optional records are ignored if present and never written.
|
|
///
|
|
/// Version is written as `600`.
|
|
///
|
|
#[derive(Debug, Clone)]
|
|
pub struct FileHeader {
|
|
/// Number of user units in one database unit
|
|
user_units_per_db_unit: f64,
|
|
/// Number of meters in one database unit
|
|
meters_per_db_unit: f64,
|
|
/// Last-modified time [y, m, d, h, m, s]
|
|
mod_time: [i16; 6],
|
|
/// Last-accessed time [y, m, d, h, m, s]
|
|
acc_time: [i16; 6],
|
|
/// Library name
|
|
name: Vec<u8>,
|
|
}
|
|
|
|
impl FileHeader {
|
|
pub fn new(name: &[u8], meters_per_db_unit: f64, user_units_per_db_unit: f64) -> Self {
|
|
FileHeader{
|
|
mod_time: [0, 1, 1, 0, 0, 0],
|
|
acc_time: [0, 1, 1, 0, 0, 0],
|
|
name: name.to_owned(),
|
|
user_units_per_db_unit,
|
|
meters_per_db_unit,
|
|
}
|
|
}
|
|
|
|
/// Read and construct a header from the provided input.
|
|
///
|
|
/// Args:
|
|
/// input: Seekable input to read from
|
|
///
|
|
/// Returns:
|
|
/// FileHeader object
|
|
///
|
|
pub fn read(input: &[u8]) -> IResult<'_, Self> {
|
|
let (input, _version) = records::HEADER::read(input)?;
|
|
let (input, [mod_time, acc_time]) = records::BGNLIB::read(input)?;
|
|
let (input, name) = records::LIBNAME::skip_and_read(input)?;
|
|
let (input, (uu, dbu)) = records::UNITS::skip_and_read(input)?;
|
|
|
|
Ok((input, FileHeader{
|
|
mod_time,
|
|
acc_time,
|
|
name,
|
|
user_units_per_db_unit: uu,
|
|
meters_per_db_unit: dbu,
|
|
}))
|
|
}
|
|
|
|
/// Write the header to a input
|
|
///
|
|
/// Args:
|
|
/// input: input to write to
|
|
///
|
|
/// Returns:
|
|
/// number of bytes written
|
|
///
|
|
pub fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
|
let mut size = 0;
|
|
size += records::HEADER::write(ww, &600)?;
|
|
size += records::BGNLIB::write(ww, &[self.mod_time, self.acc_time])?;
|
|
size += records::LIBNAME::write(ww, &self.name)?;
|
|
size += records::UNITS::write(ww, &(self.user_units_per_db_unit, self.meters_per_db_unit))?;
|
|
Ok(size)
|
|
}
|
|
}
|
|
|
|
|
|
fn make_name_list_type() -> DataType {
|
|
DataType::List(Arc::new(
|
|
Field::new_list_field(DataType::Utf8, false)
|
|
))
|
|
}
|
|
|
|
|
|
fn make_time_type() -> DataType {
|
|
DataType::FixedSizeList(Arc::new(
|
|
Field::new_list_field(DataType::Int16, false),
|
|
),
|
|
6,
|
|
)
|
|
}
|
|
|
|
|
|
fn make_top_level_builder(cells_field: Field, extra_fields: Vec<Field>) -> StructBuilder {
|
|
let mut fields = vec![
|
|
Field::new("meters_per_db_unit", DataType::Float64, false),
|
|
Field::new("user_units_per_db_unit", DataType::Float64, false),
|
|
Field::new("lib_name", DataType::Utf8, false),
|
|
Field::new("mod_time", make_time_type(), false),
|
|
Field::new("acc_time", make_time_type(), false),
|
|
cells_field,
|
|
Field::new("cell_names", make_name_list_type(), false),
|
|
];
|
|
fields.extend(extra_fields);
|
|
StructBuilder::from_fields(fields, 0)
|
|
}
|
|
|
|
|
|
fn reference_type(is_array: bool, properties: Option<&DataType>) -> DataType {
|
|
let mut fields = vec![
|
|
Field::new("target", DataType::UInt32, false),
|
|
Field::new("invert_y", DataType::Boolean, false),
|
|
Field::new("scale", DataType::Float64, false),
|
|
Field::new("angle_rad", DataType::Float64, false),
|
|
Field::new("xy", DataType::UInt64, false),
|
|
];
|
|
if is_array {
|
|
fields.extend([
|
|
Field::new("xy0", DataType::UInt64, false),
|
|
Field::new("xy1", DataType::UInt64, false),
|
|
Field::new("counts", DataType::UInt32, false),
|
|
]);
|
|
}
|
|
if let Some(properties) = properties {
|
|
fields.push(Field::new("properties", properties.clone(), true));
|
|
}
|
|
DataType::Struct(Fields::from(fields))
|
|
}
|
|
|
|
|
|
fn make_library_builder() -> StructBuilder {
|
|
let property_t = DataType::Struct(Fields::from(vec![
|
|
Field::new("key", DataType::Int16, false),
|
|
Field::new("value", DataType::Utf8, false),
|
|
]));
|
|
|
|
let property_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(property_t, false)
|
|
));
|
|
|
|
let sref_struct_t = reference_type(false, None);
|
|
let aref_struct_t = reference_type(true, None);
|
|
let sref_prop_struct_t = reference_type(false, Some(&property_list_t));
|
|
let aref_prop_struct_t = reference_type(true, Some(&property_list_t));
|
|
|
|
let text_struct_t = DataType::Struct(Fields::from(vec![
|
|
Field::new("layer", DataType::UInt32, false),
|
|
Field::new("presentation_horiz", DataType::UInt8, true),
|
|
Field::new("presentation_vert", DataType::UInt8, true),
|
|
Field::new("presentation_font", DataType::UInt8, true),
|
|
Field::new("path_type", DataType::Int16, true),
|
|
Field::new("width", DataType::Int32, true),
|
|
Field::new("invert_y", DataType::Boolean, true),
|
|
Field::new("mag", DataType::Float64, true),
|
|
Field::new("angle_deg", DataType::Float64, true),
|
|
Field::new("xy", DataType::UInt64, false),
|
|
Field::new("string", DataType::Utf8, false),
|
|
Field::new("properties", property_list_t.clone(), true),
|
|
]));
|
|
|
|
|
|
let coords_t = DataType::List(Arc::new(
|
|
Field::new_list_field(DataType::Int32, false)
|
|
));
|
|
|
|
let boundary_batch_struct_t = DataType::Struct(Fields::from(vec![
|
|
Field::new("layer", DataType::UInt32, false),
|
|
Field::new("vertices", coords_t.clone(), false),
|
|
Field::new(
|
|
"vertex_offsets",
|
|
DataType::List(Arc::new(Field::new_list_field(DataType::UInt32, false))),
|
|
false,
|
|
),
|
|
]));
|
|
|
|
let rect_batch_struct_t = DataType::Struct(Fields::from(vec![
|
|
Field::new("layer", DataType::UInt32, false),
|
|
Field::new("rects", coords_t.clone(), false),
|
|
]));
|
|
|
|
let boundary_prop_struct_t = DataType::Struct(Fields::from(vec![
|
|
Field::new("layer", DataType::UInt32, false),
|
|
Field::new("vertices", coords_t.clone(), false),
|
|
Field::new("properties", property_list_t.clone(), true),
|
|
]));
|
|
|
|
let path_struct_t = DataType::Struct(Fields::from(vec![
|
|
Field::new("layer", DataType::UInt32, false),
|
|
Field::new("path_type", DataType::Int16, true),
|
|
Field::new("extension_start", DataType::Int32, true),
|
|
Field::new("extension_end", DataType::Int32, true),
|
|
Field::new("width", DataType::Int32, true),
|
|
Field::new("xy", coords_t.clone(), false),
|
|
Field::new("properties", property_list_t.clone(), true),
|
|
]));
|
|
|
|
let boxnode_struct_t = DataType::Struct(Fields::from(vec![
|
|
Field::new("layer", DataType::UInt32, false),
|
|
Field::new("xy", coords_t.clone(), false),
|
|
Field::new("properties", property_list_t.clone(), true),
|
|
]));
|
|
|
|
let sref_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(sref_struct_t, false)
|
|
));
|
|
|
|
let aref_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(aref_struct_t, false)
|
|
));
|
|
|
|
let sref_prop_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(sref_prop_struct_t, false)
|
|
));
|
|
|
|
let aref_prop_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(aref_prop_struct_t, false)
|
|
));
|
|
|
|
let text_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(text_struct_t, false)
|
|
));
|
|
|
|
let boundary_batch_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(boundary_batch_struct_t, false)
|
|
));
|
|
|
|
let rect_batch_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(rect_batch_struct_t, false)
|
|
));
|
|
|
|
let boundary_prop_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(boundary_prop_struct_t, false)
|
|
));
|
|
|
|
let path_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(path_struct_t, false)
|
|
));
|
|
|
|
let boxnode_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(boxnode_struct_t, false)
|
|
));
|
|
|
|
let layer_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(DataType::UInt32, false)
|
|
));
|
|
|
|
let cell_struct_t = DataType::Struct(Fields::from(vec![
|
|
Field::new("id", DataType::UInt32, false),
|
|
Field::new("file_offset", DataType::UInt64, false),
|
|
Field::new("srefs", sref_list_t, false),
|
|
Field::new("arefs", aref_list_t, false),
|
|
Field::new("sref_props", sref_prop_list_t, false),
|
|
Field::new("aref_props", aref_prop_list_t, false),
|
|
Field::new("rect_batches", rect_batch_list_t, false),
|
|
Field::new("boundary_batches", boundary_batch_list_t, false),
|
|
Field::new("boundary_props", boundary_prop_list_t, false),
|
|
Field::new("paths", path_list_t, false),
|
|
Field::new("nodes", boxnode_list_t.clone(), true),
|
|
Field::new("boxes", boxnode_list_t.clone(), true),
|
|
Field::new("texts", text_list_t, false),
|
|
]));
|
|
|
|
let cells_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(cell_struct_t, false)
|
|
));
|
|
|
|
make_top_level_builder(
|
|
Field::new("cells", cells_list_t, false),
|
|
vec![
|
|
Field::new("layers", layer_list_t, false),
|
|
],
|
|
)
|
|
}
|
|
|
|
|
|
fn make_scan_builder() -> StructBuilder {
|
|
let scan_ref_struct_t = reference_type(true, None);
|
|
|
|
let scan_ref_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(scan_ref_struct_t, false)
|
|
));
|
|
|
|
let scan_cell_struct_t = DataType::Struct(Fields::from(vec![
|
|
Field::new("id", DataType::UInt32, false),
|
|
Field::new("struct_start_offset", DataType::UInt64, false),
|
|
Field::new("struct_end_offset", DataType::UInt64, false),
|
|
Field::new("refs", scan_ref_list_t, false),
|
|
]));
|
|
|
|
let scan_cells_list_t = DataType::List(Arc::new(
|
|
Field::new_list_field(scan_cell_struct_t, false)
|
|
));
|
|
|
|
make_top_level_builder(
|
|
Field::new("cells", scan_cells_list_t, false),
|
|
Vec::new(),
|
|
)
|
|
}
|
|
|
|
|
|
fn append_file_header(
|
|
lib_builder: &mut StructBuilder,
|
|
header: &FileHeader,
|
|
) -> Result<(), ErrType> {
|
|
let name = decode_name(&header.name).map_err(ErrType::Failed)?;
|
|
let dbu_builder = lib_builder.field_builder::<Float64Builder>(0).unwrap();
|
|
dbu_builder.append_value(header.meters_per_db_unit);
|
|
let uu_builder = lib_builder.field_builder::<Float64Builder>(1).unwrap();
|
|
uu_builder.append_value(header.user_units_per_db_unit);
|
|
let libname_builder = lib_builder.field_builder::<StringBuilder>(2).unwrap();
|
|
libname_builder.append_value(name);
|
|
let mtl_builder = lib_builder.field_builder::<FListBuilder>(3).unwrap();
|
|
let mt_builder = mtl_builder.values().as_any_mut().downcast_mut::<Int16Builder>().unwrap();
|
|
mt_builder.append_values(&header.mod_time, &[true; 6]);
|
|
mtl_builder.append(true);
|
|
let atl_builder = lib_builder.field_builder::<FListBuilder>(4).unwrap();
|
|
let at_builder = atl_builder.values().as_any_mut().downcast_mut::<Int16Builder>().unwrap();
|
|
at_builder.append_values(&header.acc_time, &[true; 6]);
|
|
atl_builder.append(true);
|
|
Ok(())
|
|
}
|
|
|
|
|
|
fn append_names(
|
|
lib_builder: &mut StructBuilder,
|
|
field_index: usize,
|
|
names: HashMap<String, u32>,
|
|
) {
|
|
// Interned IDs are consecutive, so a vector directly represents ID order.
|
|
let mut ordered_names = vec![String::new(); names.len()];
|
|
for (name, id) in names {
|
|
ordered_names[id as usize] = name;
|
|
}
|
|
let names_builder = lib_builder.field_builder::<DListBuilder>(field_index).unwrap();
|
|
let name_builder = names_builder.values().as_any_mut().downcast_mut::<StringBuilder>().unwrap();
|
|
for name in ordered_names {
|
|
name_builder.append_value(name);
|
|
}
|
|
names_builder.append(true);
|
|
}
|
|
|
|
|
|
fn append_layers(
|
|
lib_builder: &mut StructBuilder,
|
|
layers: HashMap<u32, u32>,
|
|
) {
|
|
let mut ordered_layers = vec![0; layers.len()];
|
|
for (layer, id) in layers {
|
|
ordered_layers[id as usize] = layer;
|
|
}
|
|
let layers_builder = lib_builder.field_builder::<DListBuilder>(7).unwrap();
|
|
let layer_builder = layers_builder.values().as_any_mut().downcast_mut::<UInt32Builder>().unwrap();
|
|
layer_builder.append_slice(&ordered_layers);
|
|
layers_builder.append(true);
|
|
}
|
|
|
|
|
|
fn append_scan_ref(
|
|
refs_builder: &mut DListBuilder,
|
|
scan_ref: ScanRefRecord,
|
|
) {
|
|
let ref_builder = refs_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
let target_builder = ref_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
target_builder.append_value(scan_ref.target_id);
|
|
let invert_builder = ref_builder.field_builder::<BooleanBuilder>(1).unwrap();
|
|
invert_builder.append_value(scan_ref.invert_y);
|
|
let scale_builder = ref_builder.field_builder::<Float64Builder>(2).unwrap();
|
|
scale_builder.append_value(scan_ref.scale);
|
|
let angle_builder = ref_builder.field_builder::<Float64Builder>(3).unwrap();
|
|
angle_builder.append_value(scan_ref.angle_rad);
|
|
let xy_builder = ref_builder.field_builder::<UInt64Builder>(4).unwrap();
|
|
xy_builder.append_value(scan_ref.xy);
|
|
let xy0_builder = ref_builder.field_builder::<UInt64Builder>(5).unwrap();
|
|
xy0_builder.append_value(scan_ref.xy0);
|
|
let xy1_builder = ref_builder.field_builder::<UInt64Builder>(6).unwrap();
|
|
xy1_builder.append_value(scan_ref.xy1);
|
|
let counts_builder = ref_builder.field_builder::<UInt32Builder>(7).unwrap();
|
|
counts_builder.append_value(scan_ref.counts);
|
|
ref_builder.append(true);
|
|
}
|
|
|
|
|
|
fn intern_name(names: &mut HashMap<String, u32>, name: String) -> u32 {
|
|
let next_id = names.len();
|
|
*names.entry(name).or_insert(next_id.try_into().unwrap())
|
|
}
|
|
|
|
|
|
fn read_cell_header<'a>(begin: &RecordFrame<'a>, input: &'a [u8]) -> IResult<'a, String> {
|
|
if begin.tag != records::RTAG_BGNSTR {
|
|
return fail(
|
|
begin.data,
|
|
format!(
|
|
"Unexpected record! Got tag 0x{:04x}, expected 0x{:04x}",
|
|
begin.tag,
|
|
records::RTAG_BGNSTR
|
|
),
|
|
);
|
|
}
|
|
begin.decode::<records::BGNSTR, _>()?;
|
|
let (input, name_bytes) = records::STRNAME::read(input)?;
|
|
let name = decode_name(&name_bytes).map_err(|error| (input, ErrType::Failed(error)))?;
|
|
Ok((input, name.to_owned()))
|
|
}
|
|
|
|
|
|
fn append_full_cell<'a>(
|
|
cells_builder: &mut DListBuilder,
|
|
names: &mut HashMap<String, u32>,
|
|
layers: &mut HashMap<u32, u32>,
|
|
struct_input: &'a [u8],
|
|
id: u32,
|
|
file_offset: u64,
|
|
) -> IResult<'a, ()> {
|
|
let cell_builder = cells_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
let id_builder = cell_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
id_builder.append_value(id);
|
|
|
|
let offset_builder = cell_builder.field_builder::<UInt64Builder>(1).unwrap();
|
|
offset_builder.append_value(file_offset);
|
|
|
|
let (next_input, _) = read_elements(struct_input, cell_builder, names, layers)?;
|
|
cell_builder.append(true);
|
|
Ok((next_input, ()))
|
|
}
|
|
|
|
|
|
fn walk_structs<'a, F>(
|
|
input: &'a [u8],
|
|
base_offset: usize,
|
|
names: &mut HashMap<String, u32>,
|
|
mut on_struct: F,
|
|
) -> IResult<'a, ()>
|
|
where
|
|
F: FnMut(&'a [u8], usize, u32, &mut HashMap<String, u32>) -> IResult<'a, ()>,
|
|
{
|
|
let input_size = input.len();
|
|
let mut input = input;
|
|
loop {
|
|
let (remaining, record) = RecordFrame::read(input)?;
|
|
match record.tag {
|
|
records::RTAG_BGNSTR => {
|
|
let record_start = base_offset + input_size - input.len();
|
|
let (after_name, name) = read_cell_header(&record, remaining)?;
|
|
let id = intern_name(names, name);
|
|
(input, ()) = on_struct(after_name, record_start, id, names)?;
|
|
}
|
|
records::RTAG_ENDLIB => {
|
|
record.decode::<records::ENDLIB, _>()?;
|
|
return Ok((remaining, ()));
|
|
}
|
|
_ => input = remaining,
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
pub fn read_library(input: &[u8]) -> IResult<'_, StructArray> {
|
|
let full_input_size = input.len();
|
|
let mut lib_builder = make_library_builder();
|
|
|
|
let (input, header) = FileHeader::read(input)?;
|
|
append_file_header(&mut lib_builder, &header).map_err(|error| (input, error))?;
|
|
let base_offset = full_input_size - input.len();
|
|
|
|
let mut names = HashMap::<String, u32>::new();
|
|
let mut layers = HashMap::<u32, u32>::new();
|
|
let cells_builder = lib_builder.field_builder::<DListBuilder>(5).unwrap();
|
|
|
|
let walk_input_size = input.len();
|
|
let (input, ()) = walk_structs(input, base_offset, &mut names, |struct_input, _record_start, id, names| {
|
|
let position = base_offset + walk_input_size - struct_input.len();
|
|
append_full_cell(
|
|
cells_builder,
|
|
names,
|
|
&mut layers,
|
|
struct_input,
|
|
id,
|
|
position.try_into().unwrap(),
|
|
)
|
|
})?;
|
|
cells_builder.append(true);
|
|
|
|
append_names(&mut lib_builder, 6, names);
|
|
append_layers(&mut lib_builder, layers);
|
|
|
|
lib_builder.append(true);
|
|
let lib = lib_builder.finish();
|
|
Ok((input, lib))
|
|
}
|
|
|
|
|
|
/// Scan cell byte ranges and references without decoding geometry.
|
|
pub fn scan_library(input: &[u8]) -> IResult<'_, StructArray> {
|
|
let full_input_size = input.len();
|
|
let mut lib_builder = make_scan_builder();
|
|
|
|
let (input, header) = FileHeader::read(input)?;
|
|
append_file_header(&mut lib_builder, &header).map_err(|error| (input, error))?;
|
|
let base_offset = full_input_size - input.len();
|
|
|
|
let mut names = HashMap::<String, u32>::new();
|
|
let cells_builder = lib_builder.field_builder::<DListBuilder>(5).unwrap();
|
|
|
|
let walk_input_size = input.len();
|
|
let (input, ()) = walk_structs(input, base_offset, &mut names, |struct_input, record_start, id, names| {
|
|
let (after_cell, refs) = scan_elements(struct_input, names)?;
|
|
let struct_end = base_offset + walk_input_size - after_cell.len();
|
|
let cell_builder = cells_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
let id_builder = cell_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
id_builder.append_value(id);
|
|
|
|
let start_builder = cell_builder.field_builder::<UInt64Builder>(1).unwrap();
|
|
start_builder.append_value(record_start.try_into().unwrap());
|
|
|
|
let end_builder = cell_builder.field_builder::<UInt64Builder>(2).unwrap();
|
|
end_builder.append_value(struct_end.try_into().unwrap());
|
|
|
|
let refs_builder = cell_builder.field_builder::<DListBuilder>(3).unwrap();
|
|
for scan_ref in refs {
|
|
append_scan_ref(refs_builder, scan_ref);
|
|
}
|
|
refs_builder.append(true);
|
|
cell_builder.append(true);
|
|
Ok((after_cell, ()))
|
|
})?;
|
|
cells_builder.append(true);
|
|
|
|
append_names(&mut lib_builder, 6, names);
|
|
|
|
lib_builder.append(true);
|
|
let lib = lib_builder.finish();
|
|
Ok((input, lib))
|
|
}
|
|
|
|
|
|
/// Read exact half-open cell ranges returned by `scan_library`, in caller order.
|
|
/// Each range includes BGNSTR through ENDSTR. Cell and layer IDs are local to
|
|
/// this result. This random-access operation returns the original input slice
|
|
/// as its remainder; it does not advance a sequential parsing cursor.
|
|
pub fn read_selected_library<'a>(input: &'a [u8], ranges: &[(u64, u64)]) -> IResult<'a, StructArray> {
|
|
let mut lib_builder = make_library_builder();
|
|
let (header_end, header) = FileHeader::read(input)?;
|
|
append_file_header(&mut lib_builder, &header).map_err(|error| (header_end, error))?;
|
|
|
|
let mut names = HashMap::<String, u32>::new();
|
|
let mut layers = HashMap::<u32, u32>::new();
|
|
let cells_builder = lib_builder.field_builder::<DListBuilder>(5).unwrap();
|
|
|
|
for (start_u64, end_u64) in ranges {
|
|
if start_u64 >= end_u64 || *end_u64 > input.len() as u64 {
|
|
return fail(input, format!("Cell byte range out of bounds: [{start_u64}, {end_u64})"));
|
|
}
|
|
let start = usize::try_from(*start_u64).unwrap();
|
|
let end = usize::try_from(*end_u64).unwrap();
|
|
|
|
let (struct_input, begin) = RecordFrame::read(&input[start..end])?;
|
|
let (struct_input, name) = read_cell_header(&begin, struct_input)?;
|
|
let file_offset = end - struct_input.len();
|
|
|
|
let id = intern_name(&mut names, name);
|
|
let (remaining_struct, _) = append_full_cell(
|
|
cells_builder,
|
|
&mut names,
|
|
&mut layers,
|
|
struct_input,
|
|
id,
|
|
file_offset.try_into().unwrap(),
|
|
)?;
|
|
if !remaining_struct.is_empty() {
|
|
return fail(remaining_struct, "Cell byte range extends past ENDSTR".to_string());
|
|
}
|
|
}
|
|
cells_builder.append(true);
|
|
|
|
append_names(&mut lib_builder, 6, names);
|
|
append_layers(&mut lib_builder, layers);
|
|
|
|
lib_builder.append(true);
|
|
let lib = lib_builder.finish();
|
|
Ok((input, lib))
|
|
}
|