Use i64 coordinate differences and checked i32 pitches in both scans and full reads. Reject nonpositive counts, malformed coordinate records, and pitches that cannot fit the packed schema.
1506 lines
52 KiB
Rust
1506 lines
52 KiB
Rust
///
|
|
/// Functionality for reading/writing elements (geometry, text labels,
|
|
/// structure references) and associated properties.
|
|
///
|
|
|
|
use crate::records::{
|
|
//BOX, BOUNDARY, NODE, PATH, TEXT, SREF, AREF,
|
|
DATATYPE, PATHTYPE, BOXTYPE, NODETYPE, TEXTTYPE,
|
|
LAYER, XY, WIDTH, COLROW, PRESENTATION, STRING,
|
|
STRANS, MAG, ANGLE, PROPATTR, PROPVALUE,
|
|
ENDEL, BGNEXTN, ENDEXTN, SNAME,
|
|
};
|
|
|
|
use crate::records;
|
|
use crate::record::{RecordHeader, Record};
|
|
use crate::basic::{IResult, fail, take_bytes}; //OResult
|
|
|
|
use std::string::String;
|
|
use std::collections::HashMap;
|
|
//use std::io::Write;
|
|
|
|
use arrow::array::{
|
|
StructBuilder, FixedSizeListBuilder, ListBuilder, StringBuilder, ArrayBuilder, BooleanBuilder,
|
|
Int32Builder, Int16Builder, UInt64Builder, UInt32Builder, UInt8Builder, Float64Builder,
|
|
};
|
|
|
|
|
|
pub type DListBuilder = ListBuilder<Box<dyn ArrayBuilder>>;
|
|
pub type FListBuilder = FixedSizeListBuilder<Box<dyn ArrayBuilder>>;
|
|
|
|
struct PropertyRecord {
|
|
key: i16,
|
|
value: String,
|
|
}
|
|
|
|
struct BoundaryRecord {
|
|
layer_id: u32,
|
|
vertices: Vec<i32>,
|
|
properties: Vec<PropertyRecord>,
|
|
}
|
|
|
|
struct BoundaryBatchRecord {
|
|
layer_id: u32,
|
|
vertices: Vec<i32>,
|
|
vertex_offsets: Vec<u32>,
|
|
}
|
|
|
|
struct RectBatchRecord {
|
|
layer_id: u32,
|
|
rects: Vec<i32>,
|
|
}
|
|
|
|
struct SRefRecord {
|
|
target_id: u32,
|
|
invert_y: bool,
|
|
scale: f64,
|
|
angle_rad: f64,
|
|
xy: u64,
|
|
properties: Vec<PropertyRecord>,
|
|
}
|
|
|
|
struct ARefRecord {
|
|
target_id: u32,
|
|
invert_y: bool,
|
|
scale: f64,
|
|
angle_rad: f64,
|
|
xy: u64,
|
|
xy0: u64,
|
|
xy1: u64,
|
|
counts: u32,
|
|
properties: Vec<PropertyRecord>,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct ScanRefRecord {
|
|
pub target_id: u32,
|
|
pub invert_y: bool,
|
|
pub scale: f64,
|
|
pub angle_rad: f64,
|
|
pub xy: u64,
|
|
pub xy0: u64,
|
|
pub xy1: u64,
|
|
pub counts: u32,
|
|
}
|
|
|
|
enum RefRecord {
|
|
SRef(SRefRecord),
|
|
ARef(ARefRecord),
|
|
}
|
|
|
|
|
|
const UNIT_COUNTS: u32 = (1_u32 << 16) | 1_u32;
|
|
const ZERO_XY: u64 = 0;
|
|
|
|
|
|
fn layer_id_for(
|
|
layer: i16,
|
|
dtype: i16,
|
|
layers: &mut HashMap<u32, u32>,
|
|
) -> u32 {
|
|
let layer32 = ((layer as u16 as u32) << 16) | (dtype as u16 as u32);
|
|
let next_id = layers.len();
|
|
*layers.entry(layer32).or_insert(next_id.try_into().unwrap())
|
|
}
|
|
|
|
|
|
fn insert_layer(
|
|
layer: i16,
|
|
dtype: i16,
|
|
layers: &mut HashMap<u32, u32>,
|
|
struct_builder: &mut StructBuilder,
|
|
field_index: usize,
|
|
) {
|
|
let id = layer_id_for(layer, dtype, layers);
|
|
let layer_builder = struct_builder.field_builder::<UInt32Builder>(field_index).unwrap();
|
|
layer_builder.append_value(id);
|
|
}
|
|
|
|
|
|
pub fn read_elements<'a>(
|
|
input: &'a [u8],
|
|
cell_builder: &mut StructBuilder,
|
|
names: &mut HashMap<String, u32>,
|
|
layers: &mut HashMap<u32, u32>,
|
|
) -> IResult<'a, ()> {
|
|
let mut input = input;
|
|
let mut boundaries = Vec::<BoundaryRecord>::new();
|
|
let mut srefs = Vec::<SRefRecord>::new();
|
|
let mut arefs = Vec::<ARefRecord>::new();
|
|
let (_, mut header) = RecordHeader::read(input)?; // don't consume tag
|
|
while header.tag != records::RTAG_ENDSTR {
|
|
(input, _) = match header.tag {
|
|
records::RTAG_SREF | records::RTAG_AREF => {
|
|
let (next_input, ref_record) = read_ref(input, header.tag, names)?;
|
|
match ref_record {
|
|
RefRecord::SRef(sref) => srefs.push(sref),
|
|
RefRecord::ARef(aref) => arefs.push(aref),
|
|
}
|
|
(next_input, ())
|
|
},
|
|
records::RTAG_BOUNDARY => {
|
|
let (next_input, boundary) = read_boundary(input, layers)?;
|
|
boundaries.push(boundary);
|
|
(next_input, ())
|
|
},
|
|
records::RTAG_PATH => read_path(input, cell_builder, layers)?,
|
|
records::RTAG_NODE => read_boxnode(input, cell_builder, header.tag, layers)?,
|
|
records::RTAG_BOX => read_boxnode(input, cell_builder, header.tag, layers)?,
|
|
records::RTAG_TEXT => read_text(input, cell_builder, layers)?,
|
|
_ => {
|
|
// don't care, skip
|
|
let result = take_bytes(input, header.data_size + 4)?;
|
|
(result.0, ())
|
|
}
|
|
};
|
|
(_, header) = RecordHeader::read(input)?; // don't consume tag
|
|
}
|
|
(input, _) = take_bytes(input, 4_usize)?; // consume endstr tag
|
|
|
|
let mut sref_plain = Vec::<SRefRecord>::with_capacity(srefs.len() + arefs.len() / 4);
|
|
let mut sref_props = Vec::<SRefRecord>::with_capacity(srefs.len() / 16 + arefs.len() / 64);
|
|
for sref in srefs {
|
|
if sref.properties.is_empty() {
|
|
sref_plain.push(sref);
|
|
} else {
|
|
sref_props.push(sref);
|
|
}
|
|
}
|
|
|
|
let mut aref_plain = Vec::<ARefRecord>::with_capacity(arefs.len());
|
|
let mut aref_props = Vec::<ARefRecord>::with_capacity(arefs.len() / 16);
|
|
for aref in arefs {
|
|
if aref.counts == UNIT_COUNTS {
|
|
let sref = aref_to_sref(aref);
|
|
if sref.properties.is_empty() {
|
|
sref_plain.push(sref);
|
|
} else {
|
|
sref_props.push(sref);
|
|
}
|
|
} else if aref.properties.is_empty() {
|
|
aref_plain.push(aref);
|
|
} else {
|
|
aref_props.push(aref);
|
|
}
|
|
}
|
|
sref_plain.sort_by_key(|sref| sref.target_id);
|
|
aref_plain.sort_by_key(|aref| aref.target_id);
|
|
|
|
let mut boundary_plain = Vec::<BoundaryRecord>::with_capacity(boundaries.len());
|
|
let mut boundary_props = Vec::<BoundaryRecord>::with_capacity(boundaries.len() / 16);
|
|
for boundary in boundaries {
|
|
if boundary.properties.is_empty() {
|
|
boundary_plain.push(boundary);
|
|
} else {
|
|
boundary_props.push(boundary);
|
|
}
|
|
}
|
|
boundary_plain.sort_by_key(|boundary| boundary.layer_id);
|
|
|
|
let mut rect_batches = Vec::<RectBatchRecord>::new();
|
|
let mut boundary_batches = Vec::<BoundaryBatchRecord>::new();
|
|
let mut ii = 0;
|
|
while ii < boundary_plain.len() {
|
|
let start = ii;
|
|
let layer_id = boundary_plain[ii].layer_id;
|
|
while ii < boundary_plain.len() && boundary_plain[ii].layer_id == layer_id {
|
|
ii += 1;
|
|
}
|
|
|
|
let group = &boundary_plain[start..ii];
|
|
let rect_capacity = group.len() * 4;
|
|
let vertex_capacity = group.iter().map(|boundary| boundary.vertices.len()).sum();
|
|
let mut rect_batch = RectBatchRecord {
|
|
layer_id,
|
|
rects: Vec::with_capacity(rect_capacity),
|
|
};
|
|
let mut boundary_batch = BoundaryBatchRecord {
|
|
layer_id,
|
|
vertices: Vec::with_capacity(vertex_capacity),
|
|
vertex_offsets: Vec::with_capacity(group.len()),
|
|
};
|
|
|
|
let mut next_offset: u32 = 0;
|
|
for boundary in group {
|
|
if let Some(rect) = boundary_to_rect(&boundary.vertices) {
|
|
rect_batch.rects.extend_from_slice(&rect);
|
|
} else {
|
|
boundary_batch.vertex_offsets.push(next_offset);
|
|
boundary_batch.vertices.extend_from_slice(&boundary.vertices);
|
|
next_offset += (boundary.vertices.len() / 2) as u32;
|
|
}
|
|
}
|
|
if !rect_batch.rects.is_empty() {
|
|
rect_batches.push(rect_batch);
|
|
}
|
|
if !boundary_batch.vertex_offsets.is_empty() {
|
|
boundary_batches.push(boundary_batch);
|
|
}
|
|
}
|
|
|
|
let sref_builder = cell_builder.field_builder::<DListBuilder>(2).unwrap();
|
|
for sref in sref_plain {
|
|
append_sref(sref_builder, sref);
|
|
}
|
|
sref_builder.append(true);
|
|
|
|
let aref_builder = cell_builder.field_builder::<DListBuilder>(3).unwrap();
|
|
for aref in aref_plain {
|
|
append_aref(aref_builder, aref);
|
|
}
|
|
aref_builder.append(true);
|
|
|
|
let sref_props_builder = cell_builder.field_builder::<DListBuilder>(4).unwrap();
|
|
for sref in sref_props {
|
|
append_sref_prop(sref_props_builder, sref);
|
|
}
|
|
sref_props_builder.append(true);
|
|
|
|
let aref_props_builder = cell_builder.field_builder::<DListBuilder>(5).unwrap();
|
|
for aref in aref_props {
|
|
append_aref_prop(aref_props_builder, aref);
|
|
}
|
|
aref_props_builder.append(true);
|
|
|
|
let rect_batches_builder = cell_builder.field_builder::<DListBuilder>(6).unwrap();
|
|
for rect_batch in rect_batches {
|
|
append_rect_batch(rect_batches_builder, rect_batch);
|
|
}
|
|
rect_batches_builder.append(true);
|
|
|
|
let boundary_batches_builder = cell_builder.field_builder::<DListBuilder>(7).unwrap();
|
|
for boundary_batch in boundary_batches {
|
|
append_boundary_batch(boundary_batches_builder, boundary_batch);
|
|
}
|
|
boundary_batches_builder.append(true);
|
|
|
|
let boundary_props_builder = cell_builder.field_builder::<DListBuilder>(8).unwrap();
|
|
for boundary in boundary_props {
|
|
append_boundary_prop(boundary_props_builder, boundary);
|
|
}
|
|
boundary_props_builder.append(true);
|
|
|
|
let paths_builder = cell_builder.field_builder::<DListBuilder>(9).unwrap();
|
|
paths_builder.append(true);
|
|
let nodes_builder = cell_builder.field_builder::<DListBuilder>(10).unwrap();
|
|
nodes_builder.append(true);
|
|
let boxes_builder = cell_builder.field_builder::<DListBuilder>(11).unwrap();
|
|
boxes_builder.append(true);
|
|
let texts_builder = cell_builder.field_builder::<DListBuilder>(12).unwrap();
|
|
texts_builder.append(true);
|
|
|
|
Ok((input, ()))
|
|
}
|
|
|
|
|
|
pub fn scan_elements<'a>(
|
|
input: &'a [u8],
|
|
names: &mut HashMap<String, u32>,
|
|
) -> IResult<'a, Vec<ScanRefRecord>> {
|
|
let mut input = input;
|
|
let mut refs = Vec::<ScanRefRecord>::new();
|
|
let (_, mut header) = RecordHeader::read(input)?;
|
|
while header.tag != records::RTAG_ENDSTR {
|
|
(input, _) = match header.tag {
|
|
records::RTAG_SREF | records::RTAG_AREF => {
|
|
let (next_input, ref_record) = read_ref(input, header.tag, names)?;
|
|
refs.push(scan_ref_from_record(ref_record));
|
|
(next_input, ())
|
|
},
|
|
records::RTAG_BOUNDARY
|
|
| records::RTAG_PATH
|
|
| records::RTAG_NODE
|
|
| records::RTAG_BOX
|
|
| records::RTAG_TEXT => skip_element(input)?,
|
|
_ => {
|
|
let result = take_bytes(input, header.data_size + 4)?;
|
|
(result.0, ())
|
|
}
|
|
};
|
|
(_, header) = RecordHeader::read(input)?;
|
|
}
|
|
refs.sort_by_key(|scan_ref| scan_ref.target_id);
|
|
(input, _) = take_bytes(input, 4_usize)?;
|
|
Ok((input, refs))
|
|
}
|
|
|
|
|
|
fn append_sref(
|
|
sref_builder: &mut DListBuilder,
|
|
sref: SRefRecord,
|
|
) {
|
|
let sref_struct_builder = sref_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
let target_builder = sref_struct_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
target_builder.append_value(sref.target_id);
|
|
let invert_builder = sref_struct_builder.field_builder::<BooleanBuilder>(1).unwrap();
|
|
invert_builder.append_value(sref.invert_y);
|
|
let scale_builder = sref_struct_builder.field_builder::<Float64Builder>(2).unwrap();
|
|
scale_builder.append_value(sref.scale);
|
|
let angle_builder = sref_struct_builder.field_builder::<Float64Builder>(3).unwrap();
|
|
angle_builder.append_value(sref.angle_rad);
|
|
let xy_builder = sref_struct_builder.field_builder::<UInt64Builder>(4).unwrap();
|
|
xy_builder.append_value(sref.xy);
|
|
|
|
sref_struct_builder.append(true);
|
|
}
|
|
|
|
|
|
fn scan_ref_from_record(ref_record: RefRecord) -> ScanRefRecord {
|
|
match ref_record {
|
|
RefRecord::SRef(sref) => ScanRefRecord {
|
|
target_id: sref.target_id,
|
|
invert_y: sref.invert_y,
|
|
scale: sref.scale,
|
|
angle_rad: sref.angle_rad,
|
|
xy: sref.xy,
|
|
xy0: ZERO_XY,
|
|
xy1: ZERO_XY,
|
|
counts: UNIT_COUNTS,
|
|
},
|
|
RefRecord::ARef(aref) => ScanRefRecord {
|
|
target_id: aref.target_id,
|
|
invert_y: aref.invert_y,
|
|
scale: aref.scale,
|
|
angle_rad: aref.angle_rad,
|
|
xy: aref.xy,
|
|
xy0: aref.xy0,
|
|
xy1: aref.xy1,
|
|
counts: aref.counts,
|
|
},
|
|
}
|
|
}
|
|
|
|
|
|
fn skip_element<'a>(input: &'a [u8]) -> IResult<'a, ()> {
|
|
let mut input = input;
|
|
loop {
|
|
let (next_input, header) = RecordHeader::read(input)?;
|
|
let (next_input, _) = take_bytes(next_input, header.data_size)?;
|
|
input = next_input;
|
|
if header.tag == ENDEL::tag() {
|
|
return Ok((input, ()));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
fn append_aref(
|
|
aref_builder: &mut DListBuilder,
|
|
aref: ARefRecord,
|
|
) {
|
|
let aref_struct_builder = aref_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
let target_builder = aref_struct_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
target_builder.append_value(aref.target_id);
|
|
let invert_builder = aref_struct_builder.field_builder::<BooleanBuilder>(1).unwrap();
|
|
invert_builder.append_value(aref.invert_y);
|
|
let scale_builder = aref_struct_builder.field_builder::<Float64Builder>(2).unwrap();
|
|
scale_builder.append_value(aref.scale);
|
|
let angle_builder = aref_struct_builder.field_builder::<Float64Builder>(3).unwrap();
|
|
angle_builder.append_value(aref.angle_rad);
|
|
let xy_builder = aref_struct_builder.field_builder::<UInt64Builder>(4).unwrap();
|
|
xy_builder.append_value(aref.xy);
|
|
let xy0_builder = aref_struct_builder.field_builder::<UInt64Builder>(5).unwrap();
|
|
xy0_builder.append_value(aref.xy0);
|
|
let xy1_builder = aref_struct_builder.field_builder::<UInt64Builder>(6).unwrap();
|
|
xy1_builder.append_value(aref.xy1);
|
|
let counts_builder = aref_struct_builder.field_builder::<UInt32Builder>(7).unwrap();
|
|
counts_builder.append_value(aref.counts);
|
|
|
|
aref_struct_builder.append(true);
|
|
}
|
|
|
|
|
|
fn append_properties(
|
|
props_builder: &mut DListBuilder,
|
|
properties: Vec<PropertyRecord>,
|
|
) {
|
|
for prop in properties {
|
|
let prop_builder = props_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
let key_builder = prop_builder.field_builder::<Int16Builder>(0).unwrap();
|
|
key_builder.append_value(prop.key);
|
|
|
|
let val_builder = prop_builder.field_builder::<StringBuilder>(1).unwrap();
|
|
val_builder.append_value(prop.value);
|
|
|
|
prop_builder.append(true);
|
|
}
|
|
props_builder.append(true);
|
|
}
|
|
|
|
|
|
fn append_sref_prop(
|
|
sref_props_builder: &mut DListBuilder,
|
|
sref: SRefRecord,
|
|
) {
|
|
let sref_prop_builder = sref_props_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
let target_builder = sref_prop_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
target_builder.append_value(sref.target_id);
|
|
let invert_builder = sref_prop_builder.field_builder::<BooleanBuilder>(1).unwrap();
|
|
invert_builder.append_value(sref.invert_y);
|
|
let scale_builder = sref_prop_builder.field_builder::<Float64Builder>(2).unwrap();
|
|
scale_builder.append_value(sref.scale);
|
|
let angle_builder = sref_prop_builder.field_builder::<Float64Builder>(3).unwrap();
|
|
angle_builder.append_value(sref.angle_rad);
|
|
let xy_builder = sref_prop_builder.field_builder::<UInt64Builder>(4).unwrap();
|
|
xy_builder.append_value(sref.xy);
|
|
|
|
let props_builder = sref_prop_builder.field_builder::<DListBuilder>(5).unwrap();
|
|
append_properties(props_builder, sref.properties);
|
|
|
|
sref_prop_builder.append(true);
|
|
}
|
|
|
|
|
|
fn append_aref_prop(
|
|
aref_props_builder: &mut DListBuilder,
|
|
aref: ARefRecord,
|
|
) {
|
|
let aref_prop_builder = aref_props_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
let target_builder = aref_prop_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
target_builder.append_value(aref.target_id);
|
|
let invert_builder = aref_prop_builder.field_builder::<BooleanBuilder>(1).unwrap();
|
|
invert_builder.append_value(aref.invert_y);
|
|
let scale_builder = aref_prop_builder.field_builder::<Float64Builder>(2).unwrap();
|
|
scale_builder.append_value(aref.scale);
|
|
let angle_builder = aref_prop_builder.field_builder::<Float64Builder>(3).unwrap();
|
|
angle_builder.append_value(aref.angle_rad);
|
|
let xy_builder = aref_prop_builder.field_builder::<UInt64Builder>(4).unwrap();
|
|
xy_builder.append_value(aref.xy);
|
|
let xy0_builder = aref_prop_builder.field_builder::<UInt64Builder>(5).unwrap();
|
|
xy0_builder.append_value(aref.xy0);
|
|
let xy1_builder = aref_prop_builder.field_builder::<UInt64Builder>(6).unwrap();
|
|
xy1_builder.append_value(aref.xy1);
|
|
let counts_builder = aref_prop_builder.field_builder::<UInt32Builder>(7).unwrap();
|
|
counts_builder.append_value(aref.counts);
|
|
|
|
let props_builder = aref_prop_builder.field_builder::<DListBuilder>(8).unwrap();
|
|
append_properties(props_builder, aref.properties);
|
|
|
|
aref_prop_builder.append(true);
|
|
}
|
|
|
|
|
|
fn aref_to_sref(aref: ARefRecord) -> SRefRecord {
|
|
SRefRecord {
|
|
target_id: aref.target_id,
|
|
invert_y: aref.invert_y,
|
|
scale: aref.scale,
|
|
angle_rad: aref.angle_rad,
|
|
xy: aref.xy,
|
|
properties: aref.properties,
|
|
}
|
|
}
|
|
|
|
|
|
fn read_boundary<'a>(
|
|
input: &'a [u8],
|
|
layers: &mut HashMap<u32, u32>,
|
|
) -> IResult<'a, BoundaryRecord> {
|
|
let (input, _) = records::BOUNDARY::read(input)?;
|
|
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
let (input, dtype) = DATATYPE::read(input)?;
|
|
let layer_id = layer_id_for(layer, dtype, layers);
|
|
|
|
let (input, xy_iter) = XY::read(input)?;
|
|
let mut vertices: Vec<i32> = xy_iter.collect();
|
|
vertices.truncate(vertices.len().saturating_sub(2));
|
|
|
|
let (input, properties) = read_properties_vec(input)?;
|
|
|
|
Ok((input, BoundaryRecord { layer_id, vertices, properties }))
|
|
}
|
|
|
|
|
|
fn append_boundary_batch(
|
|
boundary_batches_builder: &mut DListBuilder,
|
|
boundary_batch: BoundaryBatchRecord,
|
|
) {
|
|
let boundary_batch_builder = boundary_batches_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
let layer_builder = boundary_batch_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
layer_builder.append_value(boundary_batch.layer_id);
|
|
|
|
let vertices_builder = boundary_batch_builder.field_builder::<DListBuilder>(1).unwrap();
|
|
let vertex_builder = vertices_builder.values().as_any_mut().downcast_mut::<Int32Builder>().unwrap();
|
|
vertex_builder.append_slice(&boundary_batch.vertices);
|
|
vertices_builder.append(true);
|
|
|
|
let offsets_builder = boundary_batch_builder.field_builder::<DListBuilder>(2).unwrap();
|
|
let offset_builder = offsets_builder.values().as_any_mut().downcast_mut::<UInt32Builder>().unwrap();
|
|
offset_builder.append_slice(&boundary_batch.vertex_offsets);
|
|
offsets_builder.append(true);
|
|
|
|
boundary_batch_builder.append(true);
|
|
}
|
|
|
|
|
|
fn append_rect_batch(
|
|
rect_batches_builder: &mut DListBuilder,
|
|
rect_batch: RectBatchRecord,
|
|
) {
|
|
let rect_batch_builder = rect_batches_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
let layer_builder = rect_batch_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
layer_builder.append_value(rect_batch.layer_id);
|
|
|
|
let rects_builder = rect_batch_builder.field_builder::<DListBuilder>(1).unwrap();
|
|
let rect_builder = rects_builder.values().as_any_mut().downcast_mut::<Int32Builder>().unwrap();
|
|
rect_builder.append_slice(&rect_batch.rects);
|
|
rects_builder.append(true);
|
|
|
|
rect_batch_builder.append(true);
|
|
}
|
|
|
|
|
|
fn append_boundary_prop(
|
|
boundary_props_builder: &mut DListBuilder,
|
|
boundary: BoundaryRecord,
|
|
) {
|
|
let boundary_prop_builder = boundary_props_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
let layer_builder = boundary_prop_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
layer_builder.append_value(boundary.layer_id);
|
|
|
|
let vertices_builder = boundary_prop_builder.field_builder::<DListBuilder>(1).unwrap();
|
|
let vertex_builder = vertices_builder.values().as_any_mut().downcast_mut::<Int32Builder>().unwrap();
|
|
vertex_builder.append_slice(&boundary.vertices);
|
|
vertices_builder.append(true);
|
|
|
|
let props_builder = boundary_prop_builder.field_builder::<DListBuilder>(2).unwrap();
|
|
for prop in boundary.properties {
|
|
let prop_builder = props_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
let key_builder = prop_builder.field_builder::<Int16Builder>(0).unwrap();
|
|
key_builder.append_value(prop.key);
|
|
|
|
let val_builder = prop_builder.field_builder::<StringBuilder>(1).unwrap();
|
|
val_builder.append_value(prop.value);
|
|
|
|
prop_builder.append(true);
|
|
}
|
|
props_builder.append(true);
|
|
|
|
boundary_prop_builder.append(true);
|
|
}
|
|
|
|
|
|
pub fn read_path<'a>(
|
|
input: &'a [u8],
|
|
cell_builder: &mut StructBuilder,
|
|
layers: &mut HashMap<u32, u32>,
|
|
) -> IResult<'a, ()> {
|
|
let paths_builder = cell_builder.field_builder::<DListBuilder>(9).unwrap();
|
|
let path_builder = paths_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
let (input, _) = records::PATH::read(input)?;
|
|
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
let (input, dtype) = DATATYPE::read(input)?;
|
|
insert_layer(layer, dtype, layers, path_builder, 0);
|
|
|
|
let mut path_type = None;
|
|
let mut width = None;
|
|
let mut bgn_ext = None;
|
|
let mut end_ext = None;
|
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
|
while header.tag != records::RTAG_XY {
|
|
match header.tag {
|
|
records::RTAG_PATHTYPE => {
|
|
let _path_type;
|
|
(input, _path_type) = PATHTYPE::read_data(input, header.data_size)?;
|
|
path_type = Some(_path_type);
|
|
},
|
|
records::RTAG_WIDTH => {
|
|
let _width;
|
|
(input, _width) = WIDTH::read_data(input, header.data_size)?;
|
|
width = Some(_width);
|
|
},
|
|
records::RTAG_BGNEXTN => {
|
|
let _bgn_ext;
|
|
(input, _bgn_ext) = BGNEXTN::read_data(input, header.data_size)?;
|
|
bgn_ext = Some(_bgn_ext);
|
|
},
|
|
records::RTAG_ENDEXTN => {
|
|
let _end_ext;
|
|
(input, _end_ext) = ENDEXTN::read_data(input, header.data_size)?;
|
|
end_ext = Some(_end_ext);
|
|
},
|
|
_ =>
|
|
return fail(input, format!("Unexpected tag {:04x}", header.tag)),
|
|
};
|
|
(input, header) = RecordHeader::read(input)?;
|
|
}
|
|
let path_type_builder = path_builder.field_builder::<Int16Builder>(1).unwrap();
|
|
path_type_builder.append_option(path_type);
|
|
let ext0_builder = path_builder.field_builder::<Int32Builder>(2).unwrap();
|
|
ext0_builder.append_option(bgn_ext);
|
|
let ext1_builder = path_builder.field_builder::<Int32Builder>(3).unwrap();
|
|
ext1_builder.append_option(end_ext);
|
|
let width_builder = path_builder.field_builder::<Int32Builder>(4).unwrap();
|
|
width_builder.append_option(width);
|
|
|
|
let xys_builder = path_builder.field_builder::<DListBuilder>(5).unwrap();
|
|
let (input, xy_iter) = XY::read_data(input, header.data_size)?;
|
|
for xy in xy_iter {
|
|
let xy_builder = xys_builder.values().as_any_mut().downcast_mut::<Int32Builder>().unwrap();
|
|
xy_builder.append_value(xy);
|
|
}
|
|
xys_builder.append(true);
|
|
|
|
let props_builder = path_builder.field_builder::<DListBuilder>(6).unwrap();
|
|
let (input, ()) = read_properties(input, props_builder)?;
|
|
|
|
path_builder.append(true);
|
|
Ok((input, ()))
|
|
}
|
|
|
|
pub fn read_boxnode<'a>(
|
|
input: &'a [u8],
|
|
cell_builder: &mut StructBuilder,
|
|
tag: u16,
|
|
layers: &mut HashMap<u32, u32>,
|
|
) -> IResult<'a, ()> {
|
|
let field_num = match tag {
|
|
records::RTAG_NODE => 10,
|
|
records::RTAG_BOX => 11,
|
|
_ => return fail(input, format!("Unexpected tag {:04x}", tag)),
|
|
};
|
|
|
|
let boxnodes_builder = cell_builder.field_builder::<DListBuilder>(field_num).unwrap();
|
|
let boxnode_builder = boxnodes_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
let (input, _) = match tag {
|
|
records::RTAG_NODE => records::NODE::read(input)?,
|
|
records::RTAG_BOX => records::BOX::read(input)?,
|
|
_ => return fail(input, format!("Unexpected tag {:04x}", tag)),
|
|
};
|
|
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
let (input, dtype) = match tag {
|
|
records::RTAG_NODE => NODETYPE::read(input)?,
|
|
records::RTAG_BOX => BOXTYPE::read(input)?,
|
|
_ => return fail(input, format!("Unexpected tag {:04x}", tag)),
|
|
};
|
|
insert_layer(layer, dtype, layers, boxnode_builder, 0);
|
|
|
|
let xys_builder = boxnode_builder.field_builder::<DListBuilder>(1).unwrap();
|
|
let xy_builder = xys_builder.values().as_any_mut().downcast_mut::<Int32Builder>().unwrap();
|
|
let (input, xy_iter) = XY::read(input)?;
|
|
for xy in xy_iter {
|
|
xy_builder.append_value(xy);
|
|
}
|
|
xys_builder.append(true);
|
|
|
|
let props_builder = boxnode_builder.field_builder::<DListBuilder>(2).unwrap();
|
|
let (input, ()) = read_properties(input, props_builder)?;
|
|
|
|
boxnode_builder.append(true);
|
|
Ok((input, ()))
|
|
}
|
|
|
|
pub fn read_text<'a>(
|
|
input: &'a [u8],
|
|
cell_builder: &mut StructBuilder,
|
|
layers: &mut HashMap<u32, u32>,
|
|
) -> IResult<'a, ()> {
|
|
let texts_builder = cell_builder.field_builder::<DListBuilder>(12).unwrap();
|
|
let text_builder = texts_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
let mut path_type = None;
|
|
let mut pres_hori = None;
|
|
let mut pres_vert = None;
|
|
let mut pres_font = None;
|
|
let mut invert_y = None;
|
|
let mut width = None;
|
|
let mut mag = None;
|
|
let mut angle_deg = None;
|
|
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
let (input, dtype) = TEXTTYPE::read(input)?;
|
|
insert_layer(layer, dtype, layers, text_builder, 0);
|
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
|
while header.tag != records::RTAG_XY {
|
|
match header.tag {
|
|
// TODO warn if repeat tags?
|
|
records::RTAG_PRESENTATION => {
|
|
let _presentation;
|
|
(input, _presentation) = PRESENTATION::read_data(input, header.data_size)?;
|
|
pres_hori = Some(_presentation[14] as u8 * 2 + _presentation[15] as u8);
|
|
pres_vert = Some(_presentation[12] as u8 * 2 + _presentation[13] as u8);
|
|
pres_font = Some(_presentation[10] as u8 * 2 + _presentation[11] as u8);
|
|
},
|
|
records::RTAG_PATHTYPE => {
|
|
let _path_type;
|
|
(input, _path_type) = PATHTYPE::read_data(input, header.data_size)?;
|
|
path_type = Some(_path_type);
|
|
},
|
|
records::RTAG_WIDTH => {
|
|
let _width;
|
|
(input, _width) = WIDTH::read_data(input, header.data_size)?;
|
|
width = Some(_width);
|
|
},
|
|
records::RTAG_STRANS => {
|
|
let strans;
|
|
(input, strans) = STRANS::read_data(input, header.data_size)?;
|
|
invert_y = Some(strans[0]);
|
|
},
|
|
records::RTAG_MAG => {
|
|
let _mag;
|
|
(input, _mag) = MAG::read_data(input, header.data_size)?;
|
|
mag = Some(_mag);
|
|
},
|
|
records::RTAG_ANGLE => {
|
|
let _angle_deg;
|
|
(input, _angle_deg) = ANGLE::read_data(input, header.data_size)?;
|
|
angle_deg = Some(_angle_deg);
|
|
},
|
|
_ =>
|
|
return fail(input, format!("Unexpected tag {:04x}", header.tag)),
|
|
}
|
|
(input, header) = RecordHeader::read(input)?;
|
|
}
|
|
|
|
let pres_hori_builder = text_builder.field_builder::<UInt8Builder>(1).unwrap();
|
|
pres_hori_builder.append_option(pres_hori);
|
|
let pres_vert_builder = text_builder.field_builder::<UInt8Builder>(2).unwrap();
|
|
pres_vert_builder.append_option(pres_vert);
|
|
let pres_font_builder = text_builder.field_builder::<UInt8Builder>(3).unwrap();
|
|
pres_font_builder.append_option(pres_font);
|
|
let path_type_builder = text_builder.field_builder::<Int16Builder>(4).unwrap();
|
|
path_type_builder.append_option(path_type);
|
|
let width_builder = text_builder.field_builder::<Int32Builder>(5).unwrap();
|
|
width_builder.append_option(width);
|
|
let inv_builder = text_builder.field_builder::<BooleanBuilder>(6).unwrap();
|
|
inv_builder.append_option(invert_y);
|
|
let mag_builder = text_builder.field_builder::<Float64Builder>(7).unwrap();
|
|
mag_builder.append_option(mag);
|
|
let angle_builder = text_builder.field_builder::<Float64Builder>(8).unwrap();
|
|
angle_builder.append_option(angle_deg);
|
|
|
|
let (input, mut xy_iter) = XY::read_data(input, header.data_size)?;
|
|
let xx = xy_iter.next().unwrap();
|
|
let yy = xy_iter.next().unwrap();
|
|
let xy = ((xx as u32 as u64) << 32) | (yy as u32 as u64);
|
|
let xy_builder = text_builder.field_builder::<UInt64Builder>(9).unwrap();
|
|
xy_builder.append_value(xy);
|
|
|
|
let (input, string_bytes) = STRING::read(input)?;
|
|
let string = String::from_utf8(string_bytes).unwrap();
|
|
let string_builder = text_builder.field_builder::<StringBuilder>(10).unwrap();
|
|
string_builder.append_value(string);
|
|
|
|
let props_builder = text_builder.field_builder::<DListBuilder>(11).unwrap();
|
|
let (input, ()) = read_properties(input, props_builder)?;
|
|
|
|
text_builder.append(true);
|
|
Ok((input, ()))
|
|
}
|
|
|
|
|
|
fn boundary_to_rect(vertices: &[i32]) -> Option<[i32; 4]> {
|
|
if vertices.len() != 8 {
|
|
return None;
|
|
}
|
|
|
|
let xs = [vertices[0], vertices[2], vertices[4], vertices[6]];
|
|
let ys = [vertices[1], vertices[3], vertices[5], vertices[7]];
|
|
|
|
let min_x = *xs.iter().min().unwrap();
|
|
let max_x = *xs.iter().max().unwrap();
|
|
let min_y = *ys.iter().min().unwrap();
|
|
let max_y = *ys.iter().max().unwrap();
|
|
if min_x >= max_x || min_y >= max_y {
|
|
return None;
|
|
}
|
|
|
|
let mut seen_corners: u8 = 0;
|
|
for ii in 0..4 {
|
|
let jj = (ii + 1) % 4;
|
|
let dx = xs[jj] - xs[ii];
|
|
let dy = ys[jj] - ys[ii];
|
|
if (dx == 0) == (dy == 0) {
|
|
return None;
|
|
}
|
|
|
|
let x = xs[ii];
|
|
let y = ys[ii];
|
|
if (x != min_x && x != max_x) || (y != min_y && y != max_y) {
|
|
return None;
|
|
}
|
|
let code = ((x == max_x) as u8) << 1 | ((y == max_y) as u8);
|
|
seen_corners |= 1 << code;
|
|
}
|
|
|
|
if seen_corners != 0b1111 {
|
|
return None;
|
|
}
|
|
Some([min_x, min_y, max_x, max_y])
|
|
}
|
|
|
|
|
|
|
|
fn read_ref<'a>(
|
|
input: &'a [u8],
|
|
tag: u16,
|
|
names: &mut HashMap<String, u32>,
|
|
) -> IResult<'a, RefRecord> {
|
|
let (input, _) = match tag {
|
|
records::RTAG_SREF => records::SREF::read(input)?,
|
|
records::RTAG_AREF => records::AREF::read(input)?,
|
|
_ => return fail(input, format!("Unexpected tag {:04x}", tag)),
|
|
};
|
|
|
|
let is_aref = tag == records::RTAG_AREF;
|
|
let mut invert_y = false;
|
|
let mut scale = 1.0;
|
|
let mut angle_rad = 0.0;
|
|
let mut colrow = None;
|
|
|
|
let (input, struct_name_bytes) = SNAME::skip_and_read(input)?;
|
|
let struct_name = String::from_utf8(struct_name_bytes).unwrap();
|
|
let next_id = names.len();
|
|
let id = names.entry(struct_name).or_insert(next_id.try_into().unwrap());
|
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
|
while header.tag != records::RTAG_XY {
|
|
match header.tag {
|
|
records::RTAG_STRANS => {
|
|
let strans;
|
|
(input, strans) = STRANS::read_data(input, header.data_size)?;
|
|
invert_y = strans[0];
|
|
},
|
|
records::RTAG_MAG => {
|
|
let _mag;
|
|
(input, _mag) = MAG::read_data(input, header.data_size)?;
|
|
scale = _mag;
|
|
},
|
|
records::RTAG_ANGLE => {
|
|
let _angle_deg;
|
|
(input, _angle_deg) = ANGLE::read_data(input, header.data_size)?;
|
|
angle_rad = _angle_deg.to_radians();
|
|
},
|
|
records::RTAG_COLROW => {
|
|
if header.data_size != 4 {
|
|
return fail(input, "COLROW must contain two counts".to_string());
|
|
}
|
|
let mut _colrow;
|
|
(input, _colrow) = COLROW::read_data(input, header.data_size)?;
|
|
colrow = Some((_colrow.next().unwrap(), _colrow.next().unwrap()));
|
|
if !is_aref {
|
|
return fail(input, "Got a COLROW record inside an SREF".to_string());
|
|
}
|
|
},
|
|
_ =>
|
|
return fail(input, format!("Unexpected tag {:04x}", header.tag)),
|
|
};
|
|
(input, header) = RecordHeader::read(input)?;
|
|
}
|
|
|
|
let expected_xy_size = if is_aref { 24 } else { 8 };
|
|
if header.data_size != expected_xy_size {
|
|
return fail(input, format!("Expected {expected_xy_size} bytes of reference coordinates, got {}", header.data_size));
|
|
}
|
|
let (input, mut xy_iter) = XY::read_data(input, header.data_size)?;
|
|
let xx = xy_iter.next().unwrap();
|
|
let yy = xy_iter.next().unwrap();
|
|
let xy = ((xx as u32 as u64) << 32) | (yy as u32 as u64);
|
|
let (input, properties) = read_properties_vec(input)?;
|
|
|
|
if is_aref {
|
|
if colrow.is_none() {
|
|
return fail(input, "AREF without COLROW before XY".to_string())
|
|
}
|
|
let (count0, count1) = colrow.unwrap();
|
|
if count0 <= 0 || count1 <= 0 {
|
|
return fail(input, "AREF column and row counts must be positive".to_string());
|
|
}
|
|
|
|
let pitch = |end: i32, origin: i32, count: i16| {
|
|
let value = (i64::from(end) - i64::from(origin)) / i64::from(count);
|
|
i32::try_from(value).map_err(|_| (input, crate::basic::ErrType::Failed(
|
|
"AREF pitch exceeds signed 32-bit coordinate range".to_string()
|
|
)))
|
|
};
|
|
let x0a = pitch(xy_iter.next().unwrap(), xx, count0)?;
|
|
let y0a = pitch(xy_iter.next().unwrap(), yy, count0)?;
|
|
let x1a = pitch(xy_iter.next().unwrap(), xx, count1)?;
|
|
let y1a = pitch(xy_iter.next().unwrap(), yy, count1)?;
|
|
|
|
let xy0a = ((x0a as u32 as u64) << 32) | (y0a as u32 as u64);
|
|
let xy1a = ((x1a as u32 as u64) << 32) | (y1a as u32 as u64);
|
|
let counts = ((count0 as u16 as u32) << 16) | (count1 as u16 as u32);
|
|
Ok((input, RefRecord::ARef(ARefRecord {
|
|
target_id: *id,
|
|
invert_y,
|
|
scale,
|
|
angle_rad,
|
|
xy,
|
|
xy0: xy0a,
|
|
xy1: xy1a,
|
|
counts,
|
|
properties,
|
|
})))
|
|
} else {
|
|
Ok((input, RefRecord::SRef(SRefRecord {
|
|
target_id: *id,
|
|
invert_y,
|
|
scale,
|
|
angle_rad,
|
|
xy,
|
|
properties,
|
|
})))
|
|
}
|
|
}
|
|
|
|
|
|
///
|
|
/// Read element properties.
|
|
///
|
|
/// Assumes PROPATTR records have unique values.
|
|
/// Stops reading after consuming ENDEL record.
|
|
///
|
|
/// Args:
|
|
/// stream: Stream to read from.
|
|
///
|
|
/// Returns:
|
|
/// propattr: -> propvalue mapping
|
|
///
|
|
pub fn read_properties<'a>(input: &'a [u8], props_builder: &mut DListBuilder) -> IResult<'a, ()> {
|
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
|
while header.tag != ENDEL::tag() {
|
|
if header.tag == PROPATTR::tag() {
|
|
let key;
|
|
let value_bytes;
|
|
(input, key) = PROPATTR::read_data(input, header.data_size)?;
|
|
(input, value_bytes) = PROPVALUE::read(input)?;
|
|
|
|
let value = String::from_utf8(value_bytes).unwrap();
|
|
//assert!(!properties.contains_key(&key), "Duplicate property key: {}", key);
|
|
|
|
let prop_builder = props_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
let key_builder = prop_builder.field_builder::<Int16Builder>(0).unwrap();
|
|
key_builder.append_value(key);
|
|
|
|
let val_builder = prop_builder.field_builder::<StringBuilder>(1).unwrap();
|
|
val_builder.append_value(value);
|
|
|
|
prop_builder.append(true);
|
|
}
|
|
(input, header) = RecordHeader::read(input)?;
|
|
}
|
|
props_builder.append(true);
|
|
Ok((input, ()))
|
|
}
|
|
|
|
|
|
fn read_properties_vec<'a>(input: &'a [u8]) -> IResult<'a, Vec<PropertyRecord>> {
|
|
let mut properties = Vec::<PropertyRecord>::new();
|
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
|
while header.tag != ENDEL::tag() {
|
|
if header.tag == PROPATTR::tag() {
|
|
let key;
|
|
let value_bytes;
|
|
(input, key) = PROPATTR::read_data(input, header.data_size)?;
|
|
(input, value_bytes) = PROPVALUE::read(input)?;
|
|
|
|
properties.push(PropertyRecord {
|
|
key,
|
|
value: String::from_utf8(value_bytes).unwrap(),
|
|
});
|
|
}
|
|
(input, header) = RecordHeader::read(input)?;
|
|
}
|
|
|
|
Ok((input, properties))
|
|
}
|
|
|
|
/*
|
|
|
|
///
|
|
/// Write element properties.
|
|
///
|
|
/// This is does _not_ write the ENDEL record.
|
|
///
|
|
/// Args:
|
|
/// stream: Stream to write to.
|
|
///
|
|
pub fn write_properties<W: Write>(ww: &mut W, properties: &HashMap::<i16, Vec<u8>>) -> OResult {
|
|
let mut size = 0;
|
|
for (key, value) in properties {
|
|
size += PROPATTR::write(ww, key)?;
|
|
size += PROPVALUE::write(ww, value)?;
|
|
}
|
|
Ok(size)
|
|
}
|
|
|
|
pub trait Element {
|
|
///
|
|
/// Read from a stream to construct this object.
|
|
/// Consumes up to (and including) the ENDEL record.
|
|
///
|
|
fn read(input: &[u8]) -> IResult<'_, Self> where Self: Sized;
|
|
|
|
///
|
|
/// Write this element to a stream.
|
|
/// Finishes with an ENDEL record.
|
|
///
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult;
|
|
}
|
|
|
|
///
|
|
/// Datastructure representing
|
|
/// an instance of a structure (SREF / structure reference) or
|
|
/// an array of instances (AREF / array reference).
|
|
/// Type is determined by the presence of the `colrow` tuple.
|
|
///
|
|
/// Transforms are applied to each individual instance (_not_
|
|
/// to the instance's origin location || array vectors).
|
|
///
|
|
#[derive(Debug, Clone)]
|
|
pub struct Reference {
|
|
/// Name of the structure being referenced.
|
|
struct_name: Vec<u8>,
|
|
/// Whether to mirror the pattern (negate y-values / flip across x-axis). Default false.
|
|
invert_y: bool,
|
|
/// Scaling factor (default 1)
|
|
mag: f64,
|
|
/// Rotation (degrees counterclockwise)
|
|
angle_deg: f64,
|
|
|
|
/// (For SREF) Location in the parent structure corresponding to the instance's origin (0, 0).
|
|
/// (For AREF) 3 locations:
|
|
/// [`offset`,
|
|
/// `offset + col_basis_vector * colrow[0]`,
|
|
/// `offset + row_basis_vector * colrow[1]`]
|
|
/// which define the first instance's offset and the array's basis vectors.
|
|
/// Note that many GDS implementations only support manhattan basis vectors, and some
|
|
/// assume a certain axis mapping (e.g. x->columns, y->rows) and "reinterpret" the
|
|
/// basis vectors to match it.
|
|
xy: Vec<i32>,
|
|
|
|
/// Number of columns and rows (AREF) || None (SREF)
|
|
colrow: Option<(i16, i16)>,
|
|
/// Properties associated with this reference.
|
|
properties: HashMap::<i16, Vec<u8>>,
|
|
}
|
|
|
|
impl Element for Reference {
|
|
fn read(input: &[u8]) -> IResult<'_, Self> {
|
|
let mut invert_y = false;
|
|
let mut mag = 1.0;
|
|
let mut angle_deg = 0.0;
|
|
let mut colrow = None;
|
|
let (input, struct_name) = SNAME::skip_and_read(input)?;
|
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
|
while header.tag != records::RTAG_XY {
|
|
match header.tag {
|
|
records::RTAG_STRANS => {
|
|
let result = STRANS::read_data(input, header.data_size)?;
|
|
input = result.0;
|
|
invert_y = result.1[0];
|
|
},
|
|
records::RTAG_MAG =>
|
|
{(input, mag) = MAG::read_data(input, header.data_size)?;},
|
|
records::RTAG_ANGLE =>
|
|
{(input, angle_deg) = ANGLE::read_data(input, header.data_size)?;},
|
|
records::RTAG_COLROW => {
|
|
let result = COLROW::read_data(input, header.data_size)?;
|
|
input = result.0;
|
|
colrow = Some((result.1[0], result.1[1]));
|
|
},
|
|
_ =>
|
|
return fail(input, format!("Unexpected tag {:04x}", header.tag)),
|
|
};
|
|
(input, header) = RecordHeader::read(input)?;
|
|
}
|
|
let (input, xy) = XY::read_data(input, header.data_size)?;
|
|
let (input, properties) = read_properties(input)?;
|
|
Ok((input, Reference{
|
|
struct_name: struct_name,
|
|
xy: xy,
|
|
properties: properties,
|
|
colrow: colrow,
|
|
invert_y: invert_y,
|
|
mag: mag,
|
|
angle_deg: angle_deg
|
|
}))
|
|
}
|
|
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
|
let mut size = 0;
|
|
size += match self.colrow {
|
|
None => SREF::write(ww, &())?,
|
|
Some(_) => AREF::write(ww, &())?,
|
|
};
|
|
|
|
size += SNAME::write(ww, &self.struct_name)?;
|
|
if self.angle_deg != 0.0 || self.mag != 1.0 || self.invert_y {
|
|
let strans = {
|
|
let mut arr = [false; 16];
|
|
arr[0] = self.invert_y;
|
|
arr
|
|
};
|
|
size += STRANS::write(ww, &strans)?;
|
|
if self.mag != 1.0 {
|
|
size += MAG::write(ww, &self.mag)?;
|
|
}
|
|
if self.angle_deg != 0.0 {
|
|
size += ANGLE::write(ww, &self.angle_deg)?;
|
|
}
|
|
}
|
|
|
|
if let Some(cr) = self.colrow {
|
|
size += COLROW::write(ww, &vec!{cr.0, cr.1})?;
|
|
}
|
|
|
|
size += XY::write(ww, &self.xy)?;
|
|
size += write_properties(ww, &self.properties)?;
|
|
size += ENDEL::write(ww, &())?;
|
|
Ok(size)
|
|
}
|
|
}
|
|
|
|
impl Reference {
|
|
pub fn check(&self) {
|
|
if self.colrow.is_some() {
|
|
assert!(self.xy.len() != 6, "colrow is Some, so expected size-6 xy. Got {:?}", self.xy);
|
|
} else {
|
|
assert!(self.xy.len() != 2, "Expected size-2 xy. Got {:?}", self.xy);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
///
|
|
/// Datastructure representing a Boundary element.
|
|
///
|
|
#[derive(Debug, Clone)]
|
|
pub struct Boundary {
|
|
/// (layer, data_type) tuple
|
|
layer: (i16, i16),
|
|
/// Ordered vertices of the shape. First and last points should be identical. Order x0, y0, x1,...
|
|
xy: Vec<i32>,
|
|
/// Properties for the element.
|
|
properties: HashMap::<i16, Vec<u8>>,
|
|
}
|
|
|
|
impl Element for Boundary {
|
|
fn read(input: &[u8]) -> IResult<'_, Self> {
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
let (input, dtype) = DATATYPE::read(input)?;
|
|
let (input, xy) = XY::read(input)?;
|
|
let (input, properties) = read_properties(input)?;
|
|
Ok((input, Boundary{
|
|
layer: (layer, dtype),
|
|
xy: xy,
|
|
properties: properties,
|
|
}))
|
|
}
|
|
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
|
let mut size = 0;
|
|
size += BOUNDARY::write(ww, &())?;
|
|
size += LAYER::write(ww, &self.layer.0)?;
|
|
size += DATATYPE::write(ww, &self.layer.1)?;
|
|
size += XY::write(ww, &self.xy)?;
|
|
size += write_properties(ww, &self.properties)?;
|
|
size += ENDEL::write(ww, &())?;
|
|
Ok(size)
|
|
}
|
|
}
|
|
|
|
|
|
///
|
|
/// Datastructure representing a Path element.
|
|
///
|
|
/// If `path_type < 4`, `extension` values are not written.
|
|
/// During read, `exension` defaults to (0, 0) even if unused.
|
|
///
|
|
#[derive(Debug, Clone)]
|
|
pub struct Path {
|
|
/// (layer, data_type) tuple
|
|
layer: (i16, i16),
|
|
/// End-cap type (0: flush, 1: circle, 2: square, 4: custom)
|
|
path_type: i16,
|
|
/// Path width
|
|
width: i32,
|
|
/// Extension when using path_type=4. Ignored otherwise.
|
|
extension: (i32, i32),
|
|
/// Path centerline coordinates. [x0, y0, x1, y1,...]
|
|
xy: Vec<i32>,
|
|
/// Properties for the element.
|
|
properties: HashMap::<i16, Vec<u8>>,
|
|
}
|
|
|
|
impl Element for Path {
|
|
fn read(input: &[u8]) -> IResult<'_, Self> {
|
|
let mut path_type = 0;
|
|
let mut width = 0;
|
|
let mut bgn_ext = 0;
|
|
let mut end_ext = 0;
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
let (input, dtype) = DATATYPE::read(input)?;
|
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
|
while header.tag != records::RTAG_XY {
|
|
match header.tag {
|
|
records::RTAG_PATHTYPE =>
|
|
{(input, path_type) = PATHTYPE::read_data(input, header.data_size)?;},
|
|
records::RTAG_WIDTH =>
|
|
{(input, width) = WIDTH::read_data(input, header.data_size)?;},
|
|
records::RTAG_BGNEXTN =>
|
|
{(input, bgn_ext) = BGNEXTN::read_data(input, header.data_size)?;},
|
|
records::RTAG_ENDEXTN =>
|
|
{(input, end_ext) = ENDEXTN::read_data(input, header.data_size)?;},
|
|
_ =>
|
|
return fail(input, format!("Unexpected tag {:04x}", header.tag)),
|
|
};
|
|
(input, header) = RecordHeader::read(input)?;
|
|
}
|
|
let (input, xy) = XY::read_data(input, header.data_size)?;
|
|
let (input, properties) = read_properties(input)?;
|
|
Ok((input, Path{
|
|
layer: (layer, dtype),
|
|
xy: xy,
|
|
properties: properties,
|
|
extension: (bgn_ext, end_ext),
|
|
path_type: path_type,
|
|
width: width,
|
|
}))
|
|
}
|
|
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
|
let mut size = 0;
|
|
size += PATH::write(ww, &())?;
|
|
size += LAYER::write(ww, &self.layer.0)?;
|
|
size += DATATYPE::write(ww, &self.layer.1)?;
|
|
if self.path_type != 0 {
|
|
size += PATHTYPE::write(ww, &self.path_type)?;
|
|
}
|
|
if self.width != 0 {
|
|
size += WIDTH::write(ww, &self.width)?;
|
|
}
|
|
|
|
if self.path_type < 4 {
|
|
let (bgn_ext, end_ext) = self.extension;
|
|
if bgn_ext != 0 {
|
|
size += BGNEXTN::write(ww, &bgn_ext)?;
|
|
}
|
|
if end_ext != 0 {
|
|
size += ENDEXTN::write(ww, &end_ext)?;
|
|
}
|
|
}
|
|
size += XY::write(ww, &self.xy)?;
|
|
size += write_properties(ww, &self.properties)?;
|
|
size += ENDEL::write(ww, &())?;
|
|
Ok(size)
|
|
}
|
|
}
|
|
|
|
|
|
///
|
|
/// Datastructure representing a Box element. Rarely used.
|
|
///
|
|
#[derive(Debug, Clone)]
|
|
pub struct GDSBox {
|
|
/// (layer, box_type) tuple
|
|
layer: (i16, i16),
|
|
/// Box coordinates (5 pairs)
|
|
xy: Vec<i32>,
|
|
/// Properties for the element.
|
|
properties: HashMap::<i16, Vec<u8>>,
|
|
}
|
|
|
|
impl Element for GDSBox {
|
|
fn read(input: &[u8]) -> IResult<'_, Self> {
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
let (input, dtype) = BOXTYPE::read(input)?;
|
|
let (input, xy) = XY::read(input)?;
|
|
let (input, properties) = read_properties(input)?;
|
|
Ok((input, GDSBox{
|
|
layer: (layer, dtype),
|
|
xy: xy,
|
|
properties: properties,
|
|
}))
|
|
}
|
|
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
|
let mut size = 0;
|
|
size += BOX::write(ww, &())?;
|
|
size += LAYER::write(ww, &self.layer.0)?;
|
|
size += BOXTYPE::write(ww, &self.layer.1)?;
|
|
size += XY::write(ww, &self.xy)?;
|
|
size += write_properties(ww, &self.properties)?;
|
|
size += ENDEL::write(ww, &())?;
|
|
Ok(size)
|
|
}
|
|
}
|
|
|
|
|
|
///
|
|
/// Datastructure representing a Node element. Rarely used.
|
|
///
|
|
#[derive(Debug, Clone)]
|
|
pub struct Node {
|
|
/// (layer, box_type) tuple
|
|
layer: (i16, i16),
|
|
/// 1-50 pairs of coordinates.
|
|
xy: Vec<i32>,
|
|
/// Properties for the element.
|
|
properties: HashMap::<i16, Vec<u8>>,
|
|
}
|
|
|
|
impl Element for Node {
|
|
fn read(input: &[u8]) -> IResult<'_, Self> {
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
let (input, dtype) = NODETYPE::read(input)?;
|
|
let (input, xy) = XY::read(input)?;
|
|
let (input, properties) = read_properties(input)?;
|
|
Ok((input, Node{
|
|
layer: (layer, dtype),
|
|
xy: xy,
|
|
properties: properties,
|
|
}))
|
|
}
|
|
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
|
let mut size = 0;
|
|
size += NODE::write(ww, &())?;
|
|
size += LAYER::write(ww, &self.layer.0)?;
|
|
size += NODETYPE::write(ww, &self.layer.1)?;
|
|
size += XY::write(ww, &self.xy)?;
|
|
size += write_properties(ww, &self.properties)?;
|
|
size += ENDEL::write(ww, &())?;
|
|
Ok(size)
|
|
}
|
|
}
|
|
|
|
///
|
|
/// Datastructure representing a text label.
|
|
///
|
|
#[derive(Debug, Clone)]
|
|
pub struct Text {
|
|
/// (layer, node_type) tuple
|
|
layer: (i16, i16),
|
|
|
|
/// Bit array. Default all zeros.
|
|
/// bits 0-1: 00 left/01 center/10 right
|
|
/// bits 2-3: 00 top/01 middle/10 bottom
|
|
/// bits 4-5: font number
|
|
presentation: [bool; 16],
|
|
|
|
/// Default 0
|
|
path_type: i16,
|
|
/// Default 0
|
|
width: i32,
|
|
/// Vertical inversion. Default false.
|
|
invert_y: bool,
|
|
/// Scaling factor. Default 1.
|
|
mag: f64,
|
|
/// Rotation (ccw). Default 0.
|
|
angle_deg: f64,
|
|
/// Position (1 pair only)
|
|
xy: Vec<i32>,
|
|
/// Text content
|
|
string: Vec<u8>,
|
|
/// Properties for the element.
|
|
properties: HashMap::<i16, Vec<u8>>
|
|
}
|
|
|
|
impl Element for Text {
|
|
fn read(input: &[u8]) -> IResult<'_, Self> {
|
|
let mut path_type = 0;
|
|
let mut presentation = [false; 16];
|
|
let mut invert_y = false;
|
|
let mut width = 0;
|
|
let mut mag = 1.0;
|
|
let mut angle_deg = 0.0;
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
let (input, dtype) = TEXTTYPE::read(input)?;
|
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
|
while header.tag != records::RTAG_XY {
|
|
match header.tag {
|
|
records::RTAG_PRESENTATION =>
|
|
{(input, presentation) = PRESENTATION::read_data(input, header.data_size)?;},
|
|
records::RTAG_PATHTYPE =>
|
|
{(input, path_type) = PATHTYPE::read_data(input, header.data_size)?;},
|
|
records::RTAG_WIDTH =>
|
|
{(input, width) = WIDTH::read_data(input, header.data_size)?;},
|
|
records::RTAG_STRANS => {
|
|
let result = STRANS::read_data(input, header.data_size)?;
|
|
input = result.0;
|
|
invert_y = result.1[0];
|
|
},
|
|
records::RTAG_MAG =>
|
|
{(input, mag) = MAG::read_data(input, header.data_size)?;},
|
|
records::RTAG_ANGLE =>
|
|
{(input, angle_deg) = ANGLE::read_data(input, header.data_size)?;},
|
|
_ =>
|
|
return fail(input, format!("Unexpected tag {:04x}", header.tag)),
|
|
}
|
|
(input, header) = RecordHeader::read(input)?;
|
|
}
|
|
let (input, xy) = XY::read_data(input, header.data_size)?;
|
|
|
|
let (input, string) = STRING::read(input)?;
|
|
let (input, properties) = read_properties(input)?;
|
|
Ok((input, Text{
|
|
layer: (layer, dtype),
|
|
xy: xy,
|
|
properties: properties,
|
|
string: string,
|
|
presentation: presentation,
|
|
path_type: path_type,
|
|
width: width,
|
|
invert_y: invert_y,
|
|
mag: mag,
|
|
angle_deg: angle_deg,
|
|
}))
|
|
}
|
|
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
|
let mut size = 0;
|
|
size += TEXT::write(ww, &())?;
|
|
size += LAYER::write(ww, &self.layer.0)?;
|
|
size += TEXTTYPE::write(ww, &self.layer.1)?;
|
|
if self.presentation.iter().any(|&x| x) {
|
|
size += PRESENTATION::write(ww, &self.presentation)?;
|
|
}
|
|
if self.path_type != 0 {
|
|
size += PATHTYPE::write(ww, &self.path_type)?;
|
|
}
|
|
if self.width != 0 {
|
|
size += WIDTH::write(ww, &self.width)?
|
|
}
|
|
if self.angle_deg != 0.0 || self.mag != 1.0 || self.invert_y {
|
|
let strans = {
|
|
let mut arr = [false; 16];
|
|
arr[0] = self.invert_y;
|
|
arr
|
|
};
|
|
size += STRANS::write(ww, &strans)?;
|
|
if self.mag != 1.0 {
|
|
size += MAG::write(ww, &self.mag)?;
|
|
}
|
|
if self.angle_deg != 0.0 {
|
|
size += ANGLE::write(ww, &self.angle_deg)?;
|
|
}
|
|
}
|
|
size += XY::write(ww, &self.xy)?;
|
|
size += STRING::write(ww, &self.string)?;
|
|
size += write_properties(ww, &self.properties)?;
|
|
size += ENDEL::write(ww, &())?;
|
|
Ok(size)
|
|
}
|
|
}
|
|
*/
|