Introduce Pheon GDSII parsing and layout review tools
Implement native GDSII reading and writing with Arrow interchange, hierarchy scans and selective cell loading. Validate numeric packing and array pitches, and preserve normalized REAL8 encodings exactly within the supported range. Add standalone dump, structural diff, hierarchy, layer-name annotation and Git diff commands. Provide scoped text and JSON reports, deterministic comparison, and record-preserving metadata edits. Package the shared library and optional Python Arrow readers as pheon using CFFI ABI mode and Python-independent platform wheels. Include locked source builds, native API checks, cross-platform artifact workflows, documentation and regression coverage. Require Rust 1.88 or newer and Python 3.11 or newer. Validation: 87 native tests, 14 binding tests on Python 3.11/3.13/3.14, and 71 installed companion integration tests pass. Full, scanned and selected Arrow layouts match the previous schemas.
This commit is contained in:
parent
e0a634f476
commit
b3346b40a4
1 changed files with 12956 additions and 1 deletions
379
src/bin/pheon.rs
Normal file
379
src/bin/pheon.rs
Normal file
|
|
@ -0,0 +1,379 @@
|
|||
use pheon::review::report::{ReportInputs, ReportOptions, failure_report};
|
||||
use pheon::review::{
|
||||
Comparison, DisplayFilter, Document, Scope, dump_records, hierarchy, parse_layer,
|
||||
parse_layer_name, write_layer_names,
|
||||
};
|
||||
use std::{
|
||||
collections::BTreeMap,
|
||||
ffi::OsString,
|
||||
fs,
|
||||
io::{self, Write},
|
||||
path::PathBuf,
|
||||
process::ExitCode,
|
||||
};
|
||||
|
||||
const HELP: &str = "Usage:
|
||||
pheon dump FILE [--records]
|
||||
pheon diff OLD NEW [--top NAME] [--cell NAME] [--layer L/T]\n [--show-cell NAME] [--show-layer L/T] [--hierarchy ascii|mermaid|none|graph]\n [--max-changes N] [--depth N] [--format text|json]
|
||||
pheon hierarchy FILE [--format ascii|mermaid] [--depth N] [--top NAME]\n pheon git-diff [OPTIONS] -- PATH OLD OLD_OID OLD_MODE NEW NEW_OID NEW_MODE
|
||||
pheon name-layers INPUT OUTPUT --cell NAME --carrier L/T --name L:T:NAME ...
|
||||
|
||||
Object profile: ignore timestamps and element order, normalize polygon start/winding,
|
||||
preserve duplicates, compare all retained fields exactly. No geometric XOR or tolerance.
|
||||
Exit status: 0 equal/success, 1 different, 2 invalid/unsupported/incomplete.
|
||||
";
|
||||
|
||||
fn value(args: &[OsString], index: &mut usize) -> Result<String, String> {
|
||||
*index += 1;
|
||||
args.get(*index)
|
||||
.and_then(|s| s.to_str())
|
||||
.map(str::to_owned)
|
||||
.ok_or_else(|| "missing UTF-8 option value".to_string())
|
||||
}
|
||||
|
||||
fn name_layers(args: &[OsString]) -> Result<u8, String> {
|
||||
if args.len() < 2 {
|
||||
return Err(HELP.to_string());
|
||||
}
|
||||
let (mut cell, mut carrier) = (None, None);
|
||||
let mut names = BTreeMap::new();
|
||||
let mut i = 2;
|
||||
while i < args.len() {
|
||||
match args[i].to_str() {
|
||||
Some("--cell") => cell = Some(value(args, &mut i)?),
|
||||
Some("--carrier") => carrier = Some(parse_layer(&value(args, &mut i)?)?),
|
||||
Some("--name") => {
|
||||
let (pair, name) = parse_layer_name(&value(args, &mut i)?)?;
|
||||
if names.get(&pair).is_some_and(|old| old != &name) {
|
||||
return Err("conflicting --name arguments".to_string());
|
||||
}
|
||||
names.insert(pair, name);
|
||||
}
|
||||
_ => {
|
||||
return Err(
|
||||
"name-layers requires --cell, --carrier and --name arguments".to_string(),
|
||||
);
|
||||
}
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
if names.is_empty() {
|
||||
return Err("provide at least one --name".to_string());
|
||||
}
|
||||
let input = fs::read(&args[0]).map_err(|e| format!("{:?}: {e}", args[0]))?;
|
||||
let output = write_layer_names(
|
||||
&input,
|
||||
&cell.ok_or("provide --cell")?,
|
||||
carrier.ok_or("provide --carrier")?,
|
||||
&names,
|
||||
)?;
|
||||
let mut file = fs::OpenOptions::new()
|
||||
.write(true)
|
||||
.create_new(true)
|
||||
.open(&args[1])
|
||||
.map_err(|e| format!("{:?}: {e}", args[1]))?;
|
||||
if let Err(e) = file.write_all(&output).and_then(|_| file.sync_all()) {
|
||||
drop(file);
|
||||
let _ = fs::remove_file(&args[1]);
|
||||
return Err(e.to_string());
|
||||
}
|
||||
Ok(0)
|
||||
}
|
||||
|
||||
fn stdout(output: &str) -> Result<(), String> {
|
||||
io::stdout()
|
||||
.lock()
|
||||
.write_all(output.as_bytes())
|
||||
.map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
fn json_stdout(report: &serde_json::Value) -> Result<(), String> {
|
||||
let mut output = io::stdout().lock();
|
||||
serde_json::to_writer_pretty(&mut output, report).map_err(|e| e.to_string())?;
|
||||
output.write_all(b"\n").map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
fn json_diff(paths: &[OsString], scope: &Scope, options: &ReportOptions) -> Result<u8, String> {
|
||||
let inputs = ReportInputs {
|
||||
old: Some(PathBuf::from(&paths[0])),
|
||||
new: Some(PathBuf::from(&paths[1])),
|
||||
};
|
||||
let comparison = || {
|
||||
let read = |index, side| {
|
||||
fs::read(&paths[index])
|
||||
.map_err(|e| ("io_error", format!("{:?}: {e}", paths[index]), Some(side)))
|
||||
};
|
||||
let old_bytes = read(0, "old")?;
|
||||
let new_bytes = read(1, "new")?;
|
||||
let old = Document::parse(&old_bytes).map_err(|e| ("invalid_input", e, Some("old")))?;
|
||||
let new = Document::parse(&new_bytes).map_err(|e| ("invalid_input", e, Some("new")))?;
|
||||
scope
|
||||
.validate_pair(&old, &new)
|
||||
.map_err(|e| ("invalid_scope", e, None))?;
|
||||
let old = old
|
||||
.selected(scope, true)
|
||||
.map_err(|e| ("invalid_scope", e, Some("old")))?;
|
||||
let new = new
|
||||
.selected(scope, true)
|
||||
.map_err(|e| ("invalid_scope", e, Some("new")))?;
|
||||
let diff = Comparison::between(&old, &new);
|
||||
Ok::<_, (&str, String, Option<&str>)>((
|
||||
diff.json_report(&old, &new, &inputs, options),
|
||||
diff.exit_code(),
|
||||
))
|
||||
};
|
||||
let (report, status) = match comparison() {
|
||||
Ok(result) => result,
|
||||
Err((code, message, side)) => (
|
||||
failure_report(&inputs, scope, options, code, &message, side),
|
||||
2,
|
||||
),
|
||||
};
|
||||
if let Err(error) = json_stdout(&report) {
|
||||
// Once output starts, never append a second report on a write failure.
|
||||
eprintln!("pheon: {error}");
|
||||
return Ok(2);
|
||||
}
|
||||
Ok(status)
|
||||
}
|
||||
|
||||
fn run(args: &[OsString]) -> Result<u8, String> {
|
||||
if args.len() == 1 && matches!(args[0].to_str(), Some("--version" | "-V")) {
|
||||
stdout(&format!("pheon {}\n", env!("CARGO_PKG_VERSION")))?;
|
||||
return Ok(0);
|
||||
}
|
||||
if args.is_empty() || args[0] == "--help" || args[0] == "-h" {
|
||||
stdout(HELP)?;
|
||||
return Ok(0);
|
||||
}
|
||||
let command = args[0].to_str().ok_or("invalid command")?;
|
||||
if command == "name-layers" {
|
||||
return name_layers(&args[1..]);
|
||||
}
|
||||
let expected = match command {
|
||||
"dump" | "hierarchy" => 1,
|
||||
"diff" => 2,
|
||||
"git-diff" => 7,
|
||||
_ => return Err(HELP.to_string()),
|
||||
};
|
||||
let compare = command == "diff" || command == "git-diff";
|
||||
let mut scope = Scope::default();
|
||||
let mut show = DisplayFilter::default();
|
||||
let mut raw = false;
|
||||
let mut format = if compare {
|
||||
"none".to_string()
|
||||
} else {
|
||||
"ascii".to_string()
|
||||
};
|
||||
let mut max_changes = 100;
|
||||
let mut explicit_max = None;
|
||||
let mut output_format = "text".to_string();
|
||||
let mut depth = 8;
|
||||
let mut explicit_depth = false;
|
||||
let mut paths = Vec::new();
|
||||
let mut literal = false;
|
||||
let mut i = 1;
|
||||
while i < args.len() {
|
||||
if literal {
|
||||
paths.push(args[i].clone());
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
match args[i].to_str() {
|
||||
Some("--") => literal = true,
|
||||
Some("--help" | "-h") => {
|
||||
stdout(HELP)?;
|
||||
return Ok(0);
|
||||
}
|
||||
Some("--records") if command == "dump" => raw = true,
|
||||
Some("--top") => scope.top = Some(value(args, &mut i)?),
|
||||
Some("--cell") => scope.cell = Some(value(args, &mut i)?),
|
||||
Some("--layer") => scope.layer = Some(parse_layer(&value(args, &mut i)?)?),
|
||||
Some("--show-cell") if compare => show.cell = Some(value(args, &mut i)?),
|
||||
Some("--show-layer") if compare => {
|
||||
show.layer = Some(parse_layer(&value(args, &mut i)?)?)
|
||||
}
|
||||
Some("--hierarchy") if compare => format = value(args, &mut i)?,
|
||||
Some("--format") if command == "hierarchy" => format = value(args, &mut i)?,
|
||||
Some("--format") if command == "diff" => output_format = value(args, &mut i)?,
|
||||
Some("--max-changes") if compare => {
|
||||
max_changes = value(args, &mut i)?
|
||||
.parse()
|
||||
.map_err(|_| "invalid change limit")?;
|
||||
explicit_max = Some(max_changes);
|
||||
}
|
||||
Some("--depth") if command != "dump" => {
|
||||
depth = value(args, &mut i)?.parse().map_err(|_| "invalid depth")?;
|
||||
explicit_depth = true;
|
||||
}
|
||||
Some(s) if s.starts_with('-') => return Err(format!("unknown option {s:?}")),
|
||||
_ => paths.push(args[i].clone()),
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
if paths.len() != expected && !(command == "git-diff" && paths.len() == 9) {
|
||||
return Err(HELP.to_string());
|
||||
}
|
||||
if !matches!(output_format.as_str(), "text" | "json") {
|
||||
return Err("diff format must be text or json".to_string());
|
||||
}
|
||||
if output_format == "json" {
|
||||
if !matches!(format.as_str(), "none" | "graph") || explicit_depth {
|
||||
return Err(
|
||||
"JSON accepts --hierarchy graph|none; --depth applies to text output".to_string(),
|
||||
);
|
||||
}
|
||||
return json_diff(
|
||||
&paths,
|
||||
&scope,
|
||||
&ReportOptions {
|
||||
filter: show,
|
||||
max_objects: explicit_max,
|
||||
hierarchy: format == "graph",
|
||||
},
|
||||
);
|
||||
}
|
||||
if !matches!(format.as_str(), "ascii" | "mermaid" | "none")
|
||||
|| (command == "hierarchy" && format == "none")
|
||||
{
|
||||
return Err("format must be ascii or mermaid (diff also accepts none)".to_string());
|
||||
}
|
||||
let read = |path: &OsString| fs::read(path).map_err(|e| format!("{path:?}: {e}"));
|
||||
if raw {
|
||||
if scope != Scope::default() {
|
||||
return Err("record dumps do not accept object scope selectors".to_string());
|
||||
}
|
||||
stdout(&dump_records(&read(&paths[0])?)?)?;
|
||||
return Ok(0);
|
||||
}
|
||||
if !compare {
|
||||
let bytes = read(&paths[0])?;
|
||||
let doc = Document::parse(&bytes)?.selected(&scope, false)?;
|
||||
let output = if command == "dump" {
|
||||
doc.canonical_dump()
|
||||
} else {
|
||||
hierarchy(&doc, &doc, None, format == "mermaid", depth)
|
||||
};
|
||||
stdout(&output)?;
|
||||
if command == "hierarchy" {
|
||||
for issue in &doc.issues {
|
||||
eprintln!("INCOMPLETE: {issue}");
|
||||
}
|
||||
}
|
||||
return Ok(if doc.issues.is_empty() { 0 } else { 2 });
|
||||
}
|
||||
let git = command == "git-diff";
|
||||
let old_missing = git && (paths[3] == "000000" || paths[3] == ".");
|
||||
let new_missing = git && (paths[6] == "000000" || paths[6] == ".");
|
||||
if old_missing && new_missing {
|
||||
return Err("both Git revisions are absent".to_string());
|
||||
}
|
||||
let old_bytes = if old_missing {
|
||||
None
|
||||
} else {
|
||||
Some(read(&paths[if git { 1 } else { 0 }])?)
|
||||
};
|
||||
let new_bytes = if new_missing {
|
||||
None
|
||||
} else {
|
||||
Some(read(&paths[if git { 4 } else { 1 }])?)
|
||||
};
|
||||
let old = old_bytes.as_ref().map(|b| Document::parse(b)).transpose()?;
|
||||
let new = new_bytes.as_ref().map(|b| Document::parse(b)).transpose()?;
|
||||
let old = old.unwrap_or_else(|| new.as_ref().unwrap().empty_like());
|
||||
let new = new.unwrap_or_else(|| old.empty_like());
|
||||
scope.validate_pair(&old, &new)?;
|
||||
let old = old.selected(&scope, true)?;
|
||||
let new = new.selected(&scope, true)?;
|
||||
let diff = Comparison::between(&old, &new);
|
||||
let mut output = String::new();
|
||||
if git {
|
||||
if paths.len() == 9 {
|
||||
output.push_str(&format!("layout {:?} -> {:?}\n", paths[0], paths[7]));
|
||||
} else {
|
||||
output.push_str(&format!("layout {:?}\n", paths[0]));
|
||||
}
|
||||
if old_missing {
|
||||
output.push_str("layout added\n");
|
||||
} else if new_missing {
|
||||
output.push_str("layout deleted\n");
|
||||
}
|
||||
if paths[3] != paths[6] {
|
||||
output.push_str(&format!("mode {:?} -> {:?}\n", paths[3], paths[6]));
|
||||
}
|
||||
}
|
||||
output.push_str(&diff.text_filtered(max_changes, &show));
|
||||
if format != "none" {
|
||||
if format == "mermaid" {
|
||||
output.push_str("```mermaid\n");
|
||||
}
|
||||
output.push_str(&hierarchy(
|
||||
&old,
|
||||
&new,
|
||||
Some(&diff),
|
||||
format == "mermaid",
|
||||
depth,
|
||||
));
|
||||
if format == "mermaid" {
|
||||
output.push_str("```\n");
|
||||
}
|
||||
}
|
||||
stdout(&output)?;
|
||||
// Git's external driver expects successful rendering for either equality
|
||||
// or differences. Actual comparison/input failures remain nonzero.
|
||||
Ok(if git && diff.exit_code() == 1 {
|
||||
0
|
||||
} else {
|
||||
diff.exit_code()
|
||||
})
|
||||
}
|
||||
|
||||
fn wants_json(args: &[OsString]) -> bool {
|
||||
if args.first().is_none_or(|arg| arg != "diff") {
|
||||
return false;
|
||||
}
|
||||
let mut format = None;
|
||||
let mut i = 1;
|
||||
while i < args.len() {
|
||||
match args[i].to_str() {
|
||||
Some("--") => break,
|
||||
Some("--format") => {
|
||||
format = args.get(i + 1).and_then(|v| v.to_str());
|
||||
i += 1;
|
||||
}
|
||||
Some(
|
||||
"--top" | "--cell" | "--layer" | "--show-cell" | "--show-layer" | "--hierarchy"
|
||||
| "--max-changes" | "--depth",
|
||||
) => i += 1,
|
||||
_ => (),
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
format == Some("json")
|
||||
}
|
||||
|
||||
fn main() -> ExitCode {
|
||||
let args: Vec<_> = std::env::args_os().skip(1).collect();
|
||||
let json = wants_json(&args);
|
||||
match run(&args) {
|
||||
Ok(status) => ExitCode::from(status),
|
||||
Err(message) => {
|
||||
if json {
|
||||
let report = failure_report(
|
||||
&ReportInputs::default(),
|
||||
&Scope::default(),
|
||||
&ReportOptions::default(),
|
||||
"command_error",
|
||||
&message,
|
||||
None,
|
||||
);
|
||||
if let Err(error) = json_stdout(&report) {
|
||||
eprintln!("pheon: {error}");
|
||||
}
|
||||
} else {
|
||||
eprintln!("pheon: {message}");
|
||||
}
|
||||
ExitCode::from(2)
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue