From b9d74f8feb826e2de768987d17b20c1adfa91f7a Mon Sep 17 00:00:00 2001 From: 2ez4gcx <108074836+2ez4gcx@users.noreply.github.com> Date: Tue, 10 Nov 2026 03:53:09 +0700 Subject: [PATCH] Layer states: each layer once per state, and a bound on copied layers Each entry of a state copied the drawing's layer, so a small file naming one layer with a long description in many entries could take gigabytes. A state now holds each LAYER handle once; a repeated entry applies over the earlier one, which gives what restoring both in turn did, and AutoCAD 2024 restores the later of two full entries (measured). New copies are charged to one per-file budget of 256 MiB, as image-definition strings are; past it the remaining entries are left out. Co-Authored-By: Claude Opus 5.5 --- crates/io/src/dxf_layer_states.rs | 75 +++++++++++++++++++++++++++++-- crates/io/src/dxf_read/objects.rs | 3 +- 2 files changed, 73 insertions(+), 5 deletions(-) diff --git a/crates/io/src/dxf_layer_states.rs b/crates/io/src/dxf_layer_states.rs index 05844bfc9..062818d04 100644 --- a/crates/io/src/dxf_layer_states.rs +++ b/crates/io/src/dxf_layer_states.rs @@ -29,6 +29,11 @@ pub(crate) const KEY: &str = "ACAD_LAYERSTATES"; /// The prefix of a true colour in group 92. const TRUE_COLOR: u32 = 0xC200_0000; +/// The bytes of layers the states of one file may copy (CWE-400). Each entry of a state is a copy +/// of the drawing's layer, its names and description included, so without a bound a small file +/// naming one layer with a long description in a great many entries would take gigabytes. +pub(crate) const MAX_COPIED_BYTES: usize = 256 << 20; + /// Which of `states` go into AutoCAD's dictionary (the others into CADCraft's record). pub(crate) fn in_acad(states: &[LayerState]) -> Vec { let mut seen: HashSet = HashSet::with_capacity(states.len()); @@ -151,8 +156,12 @@ pub(crate) struct Lookup<'a> { } /// The state `name` from its XRECORD's groups. A layer whose record is gone (AutoCAD keeps a -/// purged layer's entry, measured) is skipped. -pub(crate) fn read(name: &str, tags: &[Tag], lookup: &Lookup) -> LayerState { +/// purged layer's entry, measured) is skipped. A layer named in two entries is in the state once, +/// the later entry's groups over the earlier one's, as restoring both in turn did: AutoCAD 2024 +/// restores the later one (measured with entries that each set every property). Each copy of a +/// layer is charged to `budget`, the file's [`MAX_COPIED_BYTES`]; once it is spent, the entries +/// left are left out. +pub(crate) fn read(name: &str, tags: &[Tag], lookup: &Lookup, budget: &mut usize) -> LayerState { let mut st = LayerState { name: name.to_string(), ..LayerState::default() }; // The data follows the subclass marker (an XRECORD without one holds none). let start = tags.iter().position(|t| t.code == 100 && t.str().trim() == "AcDbXrecord").map_or(tags.len(), |i| i + 1); @@ -167,19 +176,33 @@ pub(crate) fn read(name: &str, tags: &[Tag], lookup: &Lookup) -> LayerState { } } let rest = body.get(first..).unwrap_or_default(); + // The index in the state of each layer by its LAYER handle. + let mut index: HashMap = HashMap::new(); let mut at = 0; while let Some(group) = rest.get(at..) { let Some(head) = group.first() else { break }; let len = group.iter().skip(1).position(|t| t.code == 330).map_or(group.len(), |n| n + 1); at += len; - if let Some(mut l) = (lookup.layer)(&head.str()) { - entry(&mut l, group.get(1..len).unwrap_or_default(), lookup); + let groups = group.get(1..len).unwrap_or_default(); + let key = head.str().trim().to_ascii_uppercase(); + if let Some(slot) = index.get(&key).and_then(|&i| st.layers.get_mut(i)) { + entry(slot, groups, lookup); + } else if let Some(mut l) = (lookup.layer)(&head.str()) { + let Some(left) = budget.checked_sub(cost(&l)) else { break }; + *budget = left; + entry(&mut l, groups, lookup); + index.insert(key, st.layers.len()); st.layers.push(l); } } st } +/// The bytes a copy of layer `l` takes. +fn cost(l: &Layer) -> usize { + std::mem::size_of::() + l.name.len() + l.linetype.len() + l.description.len() + l.plot_style.len() +} + /// A layer's properties from the groups after its handle. fn entry(l: &mut Layer, groups: &[Tag], lookup: &Lookup) { let int = |t: &Tag| t.str().trim().parse::().ok(); @@ -225,3 +248,47 @@ fn entry(l: &mut Layer, groups: &[Tag], lookup: &Lookup) { l.color = Color::True(Rgb::from_u32(v & 0x00FF_FFFF)); } } + +#[cfg(test)] +mod tests { + use super::*; + + /// A state's XRECORD groups with an entry per (layer handle, colour index). + fn tags(entries: &[(&str, i64)]) -> Vec { + let mut t = vec![Tag::s(100, "AcDbXrecord"), Tag::i(280, 1), Tag::i(91, 2047), Tag::s(302, "0")]; + for (h, aci) in entries { + t.extend([Tag::s(330, *h), Tag::i(90, 8)]); + // 0: no colour group. + if *aci != 0 { + t.push(Tag::i(62, *aci)); + } + } + t + } + + #[test] + fn a_layer_named_twice_takes_its_last_entry_and_copies_stop_at_the_budget() { + let layer = |h: &str| match h { + "A1" => Some(Layer::new("A")), + "B1" => Some(Layer::new("B")), + _ => None, + }; + let none = |_: &str| None::; + let lookup = Lookup { layer: &layer, ltype: &none, pstyle: &none, colour_dependent: true }; + let colours = |st: &LayerState| st.layers.iter().map(|l| (l.name.clone(), l.color)).collect::>(); + // AutoCAD 2024 restores the last of two entries of one layer (measured: green, then blue, + // restores blue); it stays in the first one's place. A later entry without a colour keeps + // the earlier one's, as restoring both in turn did. + let mut budget = MAX_COPIED_BYTES; + let st = read("S", &tags(&[("A1", 3), ("B1", 2), ("A1", 5), ("B1", 0)]), &lookup, &mut budget); + assert_eq!(colours(&st), [("A".to_string(), Color::Index(5)), ("B".to_string(), Color::Index(2))]); + // Each new copy is charged (a repeated entry copies nothing); past the budget the rest of + // the entries, and of the file's states, are left out. + let one = cost(&Layer::new("A")); + let mut budget = one; + let st = read("S", &tags(&[("A1", 3), ("A1", 4), ("B1", 5)]), &lookup, &mut budget); + assert_eq!((colours(&st), budget), (vec![("A".to_string(), Color::Index(4))], 0)); + let st = read("T", &tags(&[("B1", 2)]), &lookup, &mut budget); + assert!(st.layers.is_empty()); + } +} diff --git a/crates/io/src/dxf_read/objects.rs b/crates/io/src/dxf_read/objects.rs index 39c5fb8b2..a33e6e2b7 100644 --- a/crates/io/src/dxf_read/objects.rs +++ b/crates/io/src/dxf_read/objects.rs @@ -107,13 +107,14 @@ impl Objects { colour_dependent: d.header.i64("PSTYLEMODE", 1) != 0, }; let mut out = Vec::new(); + let mut budget = crate::dxf_layer_states::MAX_COPIED_BYTES; for h in &self.xrecord_order { let (Some(tags), Some(name)) = (self.xrecords.get(h), self.names.get(h)) else { continue }; if out.len() >= crate::dxf_ext::MAX_LAYER_STATES { break; } if owner(tags).is_some_and(|o| dicts.contains(o.as_str())) { - out.push(crate::dxf_layer_states::read(name, tags, &lookup)); + out.push(crate::dxf_layer_states::read(name, tags, &lookup, &mut budget)); } } out