pheon/src/lib.rs
Jan Petykiewicz a04a955e90 feat(review): add deterministic GDS dumps and structural comparisons
Read embedded layer-name labels, retain unsupported records, and report affected hierarchy as ASCII or Mermaid. Preserve duplicate objects, canonicalize polygon rings, and cover the first profile with ten fixture pairs and golden outputs.
2026-11-14 17:25:04 -08:00

296 lines
10 KiB
Rust

extern crate byteorder;
pub mod basic;
pub mod record;
pub mod records;
pub mod elements;
pub mod library;
pub mod review;
use crate::library::{read_library, read_selected_library, scan_library};
use byteorder::{ByteOrder, BigEndian};
use std::any::Any;
use std::cell::RefCell;
use std::mem::size_of;
use std::ffi::{CStr, CString, c_char};
use std::panic::{AssertUnwindSafe, catch_unwind};
use std::path::{Path, PathBuf};
use std::ptr;
#[cfg(unix)]
use std::os::unix::ffi::OsStringExt;
use std::str;
use std::fs;
use std::slice;
use arrow::ffi::{to_ffi, FFI_ArrowArray, FFI_ArrowSchema};
use arrow::array::{Array, StructArray};
thread_local! {
static LAST_ERROR: RefCell<Option<CString>> = const { RefCell::new(None) };
}
fn clear_last_error() {
LAST_ERROR.with(|last_error| *last_error.borrow_mut() = None);
}
fn set_last_error(message: String) -> i32 {
let sanitized = message.replace('\0', "\\0");
LAST_ERROR.with(|last_error| *last_error.borrow_mut() = Some(CString::new(sanitized).unwrap()));
-1
}
fn describe_panic(payload: Box<dyn Any + Send>) -> String {
if let Some(message) = payload.downcast_ref::<&str>() {
(*message).to_string()
} else if let Some(message) = payload.downcast_ref::<String>() {
message.clone()
} else {
"unexpected panic".to_string()
}
}
fn describe_parse_error(input: &[u8], (remaining, reason): (&[u8], crate::basic::ErrType)) -> String {
// Selected-cell errors may contain a bounded range rather than a file suffix.
let offset = remaining.as_ptr() as usize - input.as_ptr() as usize;
let message = match reason {
crate::basic::ErrType::Failed(message) => message,
crate::basic::ErrType::Incomplete(Some(size)) => format!("Unexpected end of input; need {size} bytes"),
crate::basic::ErrType::Incomplete(None) => "Unexpected end of input".to_string(),
};
format!("at byte {offset}: {message}")
}
fn export_struct_array(
op_name: &str,
arr: *mut FFI_ArrowArray,
schema: *mut FFI_ArrowSchema,
build: impl FnOnce() -> Result<StructArray, String>,
) -> i32 {
clear_last_error();
if arr.is_null() || schema.is_null() {
return set_last_error(format!("{op_name}: Arrow output pointer was null"));
}
match catch_unwind(AssertUnwindSafe(build)) {
Ok(Ok(struct_arr)) => match to_ffi(&struct_arr.to_data()) {
Ok((ffi_arr, ffi_schema)) => {
unsafe {
*arr = ffi_arr;
*schema = ffi_schema;
}
0
},
Err(err) => set_last_error(format!("{op_name}: failed to export Arrow data: {err}")),
},
Ok(Err(message)) => set_last_error(format!("{op_name}: {message}")),
Err(payload) => set_last_error(format!("{op_name}: {}", describe_panic(payload))),
}
}
fn pathbuf_from_c(cpath: *const c_char) -> Result<PathBuf, String> {
if cpath.is_null() {
return Err("path pointer was null".to_string());
}
let cstr = unsafe { CStr::from_ptr(cpath) };
#[cfg(unix)]
{
return Ok(PathBuf::from(std::ffi::OsString::from_vec(cstr.to_bytes().to_vec())));
}
#[cfg(windows)]
{
let ustr = str::from_utf8(cstr.to_bytes())
.map_err(|_| "Non-UTF8 paths are not supported".to_string())?;
return Ok(PathBuf::from(ustr));
}
#[allow(unreachable_code)]
Err("Unsupported OS".to_string())
}
/// Return this thread's last parser error, or null if its last call succeeded.
/// The returned string remains valid until this thread's next parser call or exit.
#[unsafe(no_mangle)]
pub extern "C" fn last_error_message() -> *const c_char {
LAST_ERROR.with(|last_error| last_error.borrow()
.as_ref()
.map_or(ptr::null(), |message| message.as_ptr()))
}
/// Read a GDSII file and export its Arrow data. Return 0 on success or -1 on error.
///
/// # Safety
/// `cpath` must point to a null-terminated path. Non-null output pointers must
/// point to initialized, writable Arrow FFI structures. Null pointers are rejected.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn read_path(
cpath: *const c_char,
arr: *mut FFI_ArrowArray,
schema: *mut FFI_ArrowSchema,
) -> i32 {
export_struct_array("read_path", arr, schema, || {
let path = pathbuf_from_c(cpath)?;
let input = fs::read(Path::new(&path))
.map_err(|err| format!("file read failed for {}: {err}", path.display()))?;
let (_input, struct_arr) = read_library(&input)
.map_err(|err| format!("read failed {}", describe_parse_error(&input, err)))?;
Ok(struct_arr)
})
}
unsafe fn input_slice<'a, T>(data: *const T, size: usize, name: &str) -> Result<&'a [T], String> {
if size == 0 {
return Ok(&[]);
}
if data.is_null() {
return Err(format!("{name} pointer was null"));
}
if !data.is_aligned() {
return Err(format!("{name} pointer was misaligned"));
}
if size.checked_mul(size_of::<T>()).is_none_or(|bytes| bytes > isize::MAX as usize) {
return Err(format!("{name} length is too large"));
}
Ok(unsafe { slice::from_raw_parts(data, size) })
}
/// Scan cell ranges and hierarchy references. Return 0 on success or -1 on error.
///
/// # Safety
/// Non-null `data` must point to `size` readable bytes. Null is allowed when
/// `size` is zero. Output pointers have the same requirements as `read_path`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn scan_bytes(
data: *const u8,
size: usize,
arr: *mut FFI_ArrowArray,
schema: *mut FFI_ArrowSchema,
) -> i32 {
export_struct_array("scan_bytes", arr, schema, || {
let input = unsafe { input_slice(data, size, "data") }?;
let (_input, struct_arr) = scan_library(input)
.map_err(|err| format!("scan failed {}", describe_parse_error(input, err)))?;
Ok(struct_arr)
})
}
/// Read the cells in half-open byte ranges. Return 0 on success or -1 on error.
///
/// # Safety
/// `data` has the same requirements as `scan_bytes`. Non-null `ranges` must
/// point to `range_count * 2` readable, aligned u64 values, alternating start
/// and end offsets. Null is allowed for zero ranges. Output pointers have the
/// same requirements as `read_path`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn read_cells_bytes(
data: *const u8,
size: usize,
ranges: *const u64,
range_count: usize,
arr: *mut FFI_ArrowArray,
schema: *mut FFI_ArrowSchema,
) -> i32 {
export_struct_array("read_cells_bytes", arr, schema, || {
let input = unsafe { input_slice(data, size, "data") }?;
let range_size = range_count.checked_mul(2)
.ok_or_else(|| "range count is too large".to_string())?;
let flat_ranges = unsafe { input_slice(ranges, range_size, "ranges") }?;
let cell_ranges: Vec<(u64, u64)> = flat_ranges
.chunks_exact(2)
.map(|chunk| (chunk[0], chunk[1]))
.collect();
let (_input, struct_arr) = read_selected_library(input, &cell_ranges)
.map_err(|err| format!("selected-cell read failed {}", describe_parse_error(input, err)))?;
Ok(struct_arr)
})
}
macro_rules! impl_i16be {
( $tt:ty, $arr:ident, $size:ident ) => {
{
let sl = unsafe { std::slice::from_raw_parts_mut($arr, $size) };
for xx in sl.iter_mut() {
// All source types represent the target bounds exactly in f64.
let value = *xx as f64;
if !value.is_finite() || value < i16::MIN as f64 || value > i16::MAX as f64 {
return *xx;
}
let mut buf = [0; size_of::<$tt>()];
BigEndian::write_i16(&mut buf, *xx as i16);
*xx = <$tt>::from_ne_bytes(buf);
}
0 as $tt
}
}
}
macro_rules! impl_i32be {
( $tt:ty, $arr:ident, $size:ident ) => {
{
let sl = unsafe { std::slice::from_raw_parts_mut($arr, $size) };
for xx in sl.iter_mut() {
let value = *xx as f64;
if !value.is_finite() || value < i32::MIN as f64 || value > i32::MAX as f64 {
return *xx;
}
let mut buf = [0; size_of::<$tt>()];
BigEndian::write_i32(&mut buf, *xx as i32);
*xx = <$tt>::from_ne_bytes(buf);
}
0 as $tt
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn f64_to_i16(arr: *mut f64, size: usize) -> f64 { impl_i16be!(f64, arr, size) }
#[unsafe(no_mangle)]
pub unsafe extern "C" fn f64_to_i32(arr: *mut f64, size: usize) -> f64 { impl_i32be!(f64, arr, size) }
#[unsafe(no_mangle)]
pub unsafe extern "C" fn f32_to_i16(arr: *mut f32, size: usize) -> f32 { impl_i16be!(f32, arr, size) }
#[unsafe(no_mangle)]
pub unsafe extern "C" fn f32_to_i32(arr: *mut f32, size: usize) -> f32 { impl_i32be!(f32, arr, size) }
#[unsafe(no_mangle)]
pub unsafe extern "C" fn u64_to_i16(arr: *mut u64, size: usize) -> u64 { impl_i16be!(u64, arr, size) }
#[unsafe(no_mangle)]
pub unsafe extern "C" fn u64_to_i32(arr: *mut u64, size: usize) -> u64 { impl_i32be!(u64, arr, size) }
#[unsafe(no_mangle)]
pub unsafe extern "C" fn i64_to_i16(arr: *mut i64, size: usize) -> i64 { impl_i16be!(i64, arr, size) }
#[unsafe(no_mangle)]
pub unsafe extern "C" fn i64_to_i32(arr: *mut i64, size: usize) -> i64 { impl_i32be!(i64, arr, size) }
#[unsafe(no_mangle)]
pub unsafe extern "C" fn u32_to_i16(arr: *mut u32, size: usize) -> u32 { impl_i16be!(u32, arr, size) }
#[unsafe(no_mangle)]
pub unsafe extern "C" fn u32_to_i32(arr: *mut u32, size: usize) -> u32 { impl_i32be!(u32, arr, size) }
#[unsafe(no_mangle)]
pub unsafe extern "C" fn i32_to_i16(arr: *mut i32, size: usize) -> i32 { impl_i16be!(i32, arr, size) }
#[unsafe(no_mangle)]
pub unsafe extern "C" fn i32_to_i32(arr: *mut i32, size: usize) -> i32 { impl_i32be!(i32, arr, size) }
#[unsafe(no_mangle)]
pub unsafe extern "C" fn u16_to_i16(arr: *mut u16, size: usize) -> u16 { impl_i16be!(u16, arr, size) }
#[unsafe(no_mangle)]
pub unsafe extern "C" fn i16_to_i16(arr: *mut i16, size: usize) -> i16 { impl_i16be!(i16, arr, size) }