mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 12:38:18 +00:00
Merge pull request #8515 from dotCooCoo/perf/eps-token-search-in-place
EPS import: token and search read a string in place instead of copying it
This commit is contained in:
@@ -70,6 +70,8 @@ mod tests_native;
|
||||
#[cfg(test)]
|
||||
mod tests_reads;
|
||||
#[cfg(test)]
|
||||
mod tests_strings;
|
||||
#[cfg(test)]
|
||||
mod tests_type1;
|
||||
#[cfg(test)]
|
||||
mod tests_type42;
|
||||
|
||||
@@ -146,13 +146,21 @@ impl Interp<'_> {
|
||||
fn token(&mut self) -> Res {
|
||||
match self.pop()? {
|
||||
Obj::Str(s) => {
|
||||
let bytes = s.to_vec();
|
||||
let mut lex = Lexer::new(&bytes);
|
||||
let Some(o) = lex.next()? else { return self.push(Obj::Bool(false)) };
|
||||
let o = self.scanned(o, lex.immediate)?;
|
||||
// The whitespace after the token is read with it.
|
||||
let used = bytes.len() - lex.data().len();
|
||||
self.push_interval(Obj::Str(s), used, bytes.len() - used)?;
|
||||
// The scanner reads the string in place. The borrow ends before `scanned`, which
|
||||
// can fail or charge the budget, and before the results are pushed.
|
||||
let read = {
|
||||
let bytes = s.borrow();
|
||||
let mut lex = Lexer::new(&bytes);
|
||||
// The whitespace after the token is read with it.
|
||||
lex.next()?.map(|o| {
|
||||
let immediate = lex.immediate;
|
||||
let rest = lex.data().len();
|
||||
(o, immediate, bytes.len() - rest, rest)
|
||||
})
|
||||
};
|
||||
let Some((o, immediate, used, rest)) = read else { return self.push(Obj::Bool(false)) };
|
||||
let o = self.scanned(o, immediate)?;
|
||||
self.push_interval(Obj::Str(s), used, rest)?;
|
||||
self.push(o)?;
|
||||
}
|
||||
Obj::File { stream: f, .. } => {
|
||||
|
||||
@@ -753,21 +753,25 @@ impl<'a> Interp<'a> {
|
||||
}
|
||||
|
||||
fn search_string(&mut self, op: Op) -> Res {
|
||||
let seek = self.pop_str()?.to_vec();
|
||||
let seek = self.pop_str()?;
|
||||
let s = self.pop_str()?;
|
||||
let text = s.to_vec();
|
||||
self.spend((text.len() / 64) as u64)?;
|
||||
let at = if op == Op::Search { super::lex::find(&text, &seek) } else { text.starts_with(&seek).then_some(0) };
|
||||
// Both strings are read in place, and the borrows end before the results are pushed.
|
||||
let (len, n, at) = {
|
||||
let (text, seek) = (s.borrow(), seek.borrow());
|
||||
self.spend((text.len() / 64) as u64)?;
|
||||
let at = if op == Op::Search { super::lex::find(&text, &seek) } else { text.starts_with(&seek).then_some(0) };
|
||||
(text.len(), seek.len(), at)
|
||||
};
|
||||
match at {
|
||||
Some(i) => {
|
||||
let o = Obj::Str(s);
|
||||
if op == Op::Search {
|
||||
self.push_interval(o.clone(), i + seek.len(), text.len() - i - seek.len())?;
|
||||
self.push_interval(o.clone(), i, seek.len())?;
|
||||
self.push_interval(o.clone(), i + n, len - i - n)?;
|
||||
self.push_interval(o.clone(), i, n)?;
|
||||
self.push_interval(o, 0, i)?;
|
||||
} else {
|
||||
self.push_interval(o.clone(), seek.len(), text.len() - seek.len())?;
|
||||
self.push_interval(o, 0, seek.len())?;
|
||||
self.push_interval(o.clone(), n, len - n)?;
|
||||
self.push_interval(o, 0, n)?;
|
||||
}
|
||||
self.push(Obj::Bool(true))?;
|
||||
}
|
||||
|
||||
@@ -49,6 +49,8 @@ thread_local! {
|
||||
/// Tests: the arrays of the list last released on this thread that were still alive after it
|
||||
/// (the ones the interpreter itself still held).
|
||||
pub(crate) static ARRAYS_LEFT: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
||||
/// Tests: how many values [`Shared::to_vec`] has copied on this thread.
|
||||
pub(crate) static VALUES_COPIED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
||||
}
|
||||
|
||||
thread_local! {
|
||||
@@ -340,7 +342,10 @@ impl<T: Clone + Held> Shared<T> {
|
||||
}
|
||||
|
||||
pub fn to_vec(&self) -> Vec<T> {
|
||||
self.borrow().to_vec()
|
||||
let v = self.borrow().to_vec();
|
||||
#[cfg(test)]
|
||||
VALUES_COPIED.with(|n| n.set(n.get() + v.len()));
|
||||
v
|
||||
}
|
||||
|
||||
/// `n` values from `at`, sharing the storage (`getinterval`); `None` past the end.
|
||||
|
||||
@@ -0,0 +1,306 @@
|
||||
//! `token` on a string, `search` and `anchorsearch` (PLRM 3rd ed., pp. 702-703, 655 and 529) read
|
||||
//! their strings in place. The tests run them next to reference readers that copy the strings
|
||||
//! first, on the same operands in the same interpreter state: the operand stack, the error and the
|
||||
//! operations spent must agree.
|
||||
|
||||
use std::hash::{DefaultHasher, Hash, Hasher};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use vectorcraft_doc::Document;
|
||||
use vectorcraft_geom::{Affine, Rect};
|
||||
|
||||
use super::graphics::{GState, Out};
|
||||
use super::interp::Interp;
|
||||
use super::lex::Lexer;
|
||||
use super::obj::{Obj, Op, PsError, Res, Shared, VALUES_COPIED};
|
||||
|
||||
/// An interpreter that has run `src`, with the operands it left.
|
||||
fn after(src: &[u8]) -> Interp<'_> {
|
||||
let mut doc = Document::new(100.0, 100.0);
|
||||
doc.layers.clear();
|
||||
let page = Affine::new([1.0, 0.0, 0.0, -1.0, 0.0, 100.0]);
|
||||
let mut it = Interp::new(src, GState::default(), Out::new(doc, page, Rect::new(0.0, 0.0, 100.0, 100.0)));
|
||||
assert_eq!(it.run(), Ok(()), "{}", String::from_utf8_lossy(src));
|
||||
it
|
||||
}
|
||||
|
||||
/// The reference `token`: the string copied before it is scanned.
|
||||
fn token_by_copy(it: &mut Interp) -> Res {
|
||||
match it.pop()? {
|
||||
Obj::Str(s) => {
|
||||
let bytes = s.to_vec();
|
||||
let mut lex = Lexer::new(&bytes);
|
||||
let Some(o) = lex.next()? else { return it.push(Obj::Bool(false)) };
|
||||
let o = it.scanned(o, lex.immediate)?;
|
||||
let used = bytes.len() - lex.data().len();
|
||||
it.push_interval(Obj::Str(s), used, bytes.len() - used)?;
|
||||
it.push(o)?;
|
||||
}
|
||||
Obj::File { stream: f, .. } => {
|
||||
let (o, immediate) = it.next_in(&f)?;
|
||||
let Some(o) = o else { return it.push(Obj::Bool(false)) };
|
||||
let o = it.scanned(o, immediate)?;
|
||||
it.push(o)?;
|
||||
}
|
||||
_ => return Err(PsError::Ps("typecheck", "token".into())),
|
||||
}
|
||||
it.push(Obj::Bool(true))
|
||||
}
|
||||
|
||||
/// The reference `search` and `anchorsearch`: both strings copied before they are compared.
|
||||
fn search_by_copy(it: &mut Interp, op: Op) -> Res {
|
||||
let seek = it.pop_str()?.to_vec();
|
||||
let s = it.pop_str()?;
|
||||
let text = s.to_vec();
|
||||
it.spend((text.len() / 64) as u64)?;
|
||||
let at = if op == Op::Search { super::lex::find(&text, &seek) } else { text.starts_with(&seek).then_some(0) };
|
||||
match at {
|
||||
Some(i) => {
|
||||
let o = Obj::Str(s);
|
||||
if op == Op::Search {
|
||||
it.push_interval(o.clone(), i + seek.len(), text.len() - i - seek.len())?;
|
||||
it.push_interval(o.clone(), i, seek.len())?;
|
||||
it.push_interval(o, 0, i)?;
|
||||
} else {
|
||||
it.push_interval(o.clone(), seek.len(), text.len() - seek.len())?;
|
||||
it.push_interval(o, 0, seek.len())?;
|
||||
}
|
||||
it.push(Obj::Bool(true))?;
|
||||
}
|
||||
None => {
|
||||
it.push(Obj::Str(s))?;
|
||||
it.push(Obj::Bool(false))?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn by_copy(it: &mut Interp, op: Op) -> Res {
|
||||
if op == Op::Token { token_by_copy(it) } else { search_by_copy(it, op) }
|
||||
}
|
||||
|
||||
/// The error's name, or the limit reached.
|
||||
fn outcome(r: Res) -> Result<(), String> {
|
||||
r.map_err(|e| match e {
|
||||
PsError::Ps(name, _) => name.to_string(),
|
||||
e => format!("{e:?}"),
|
||||
})
|
||||
}
|
||||
|
||||
/// Everything the operator left: the operand stack with each string's storage, offset and length,
|
||||
/// and the operations spent.
|
||||
fn state(it: &Interp) -> (String, u64) {
|
||||
(format!("{:?}", it.stack), it.ops_left())
|
||||
}
|
||||
|
||||
/// Run `op` on the operands `src` leaves, in place and by copy, `steps` times (a walk that feeds
|
||||
/// each call the string the last one left), and check that the two agree after every call.
|
||||
fn agree(src: &str, op: Op, steps: usize) {
|
||||
let (mut new, mut old) = (after(src.as_bytes()), after(src.as_bytes()));
|
||||
// `search` and `anchorsearch` look for the same string on each call.
|
||||
let seeks = [new.stack.last().cloned(), old.stack.last().cloned()];
|
||||
for step in 0..steps {
|
||||
let (a, b) = (outcome(new.op(op)), outcome(by_copy(&mut old, op)));
|
||||
assert_eq!(a, b, "{src} {op:?}, call {step}");
|
||||
assert_eq!(state(&new), state(&old), "{src} {op:?}, call {step}");
|
||||
// Keep walking while the operator answered true, with the string it left.
|
||||
let more = matches!(new.stack.last(), Some(Obj::Bool(true)));
|
||||
if a.is_err() || !more {
|
||||
break;
|
||||
}
|
||||
for (it, seek) in [&mut new, &mut old].into_iter().zip(&seeks) {
|
||||
it.stack.pop();
|
||||
// `token` leaves the rest under the object; `search` leaves it under match and pre
|
||||
// (and `anchorsearch` under the match).
|
||||
let keep = it.stack.len() - if op == Op::Search { 2 } else { 1 };
|
||||
it.stack.truncate(keep);
|
||||
// The string to look for again, or the file `token` reads on from.
|
||||
if op != Op::Token || matches!(seek, Some(Obj::File { .. })) {
|
||||
it.stack.extend(seek.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
new.release();
|
||||
old.release();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn token_and_search_agree_with_copying_readers() {
|
||||
let tokens = [
|
||||
"()",
|
||||
"( )",
|
||||
"(\r\n\t )",
|
||||
"(12)",
|
||||
"(12 34)",
|
||||
"(12 34)",
|
||||
"(12\r\n34)",
|
||||
"(/x {a b} (s) <41> 1.5 x)",
|
||||
"(1 {)",
|
||||
"( [ 1 ] )",
|
||||
"/x 7 def (//x {//x} y)",
|
||||
"(xx12 34 56) 2 7 getinterval",
|
||||
"(%comment only)",
|
||||
"5",
|
||||
"(12 /x {a}) /ReusableStreamDecode filter",
|
||||
"currentfile",
|
||||
];
|
||||
for src in tokens {
|
||||
agree(src, Op::Token, 16);
|
||||
}
|
||||
let searches = [
|
||||
"(abcabc) (bc)",
|
||||
"(abc) (x)",
|
||||
"(abc) ()",
|
||||
"() ()",
|
||||
"() (a)",
|
||||
"(ab) (abc)",
|
||||
"(a\nb\nc\n) (\n)",
|
||||
"/s (aa) def s s",
|
||||
"(xxab cd ef) 2 8 getinterval ( )",
|
||||
"(abc) 5",
|
||||
"5 (abc)",
|
||||
];
|
||||
for src in searches {
|
||||
agree(src, Op::Search, 8);
|
||||
agree(src, Op::AnchorSearch, 8);
|
||||
}
|
||||
// Over the operation budget: the same error, with the same operands popped.
|
||||
let big = "/h 65536 string def h (\\001)";
|
||||
let (mut new, mut old) = (after(big.as_bytes()), after(big.as_bytes()));
|
||||
for it in [&mut new, &mut old] {
|
||||
let left = it.ops_left();
|
||||
assert_eq!(it.spend(left.saturating_sub(10)), Ok(()));
|
||||
}
|
||||
let (a, b) = (outcome(new.op(Op::Search)), outcome(by_copy(&mut old, Op::Search)));
|
||||
assert!(a.as_ref().is_err_and(|e| e.contains("too long")), "{a:?}");
|
||||
assert_eq!((a, state(&new)), (b, state(&old)));
|
||||
new.release();
|
||||
old.release();
|
||||
}
|
||||
|
||||
/// The results share the string's storage: a write to the string after `token` or `search` shows
|
||||
/// in what they left.
|
||||
#[test]
|
||||
fn token_and_search_results_see_later_writes() {
|
||||
let check = super::tests::check;
|
||||
check("/s (12 34) def s token pop pop /post exch def s 3 57 put post token pop exch pop 94 eq");
|
||||
check("/s (ab cd) def s ( ) search pop /pre exch def pop /post exch def s 0 120 put s 4 121 put pre (xb) eq post (cy) eq and");
|
||||
check("/s (ab cd) def s (ab) anchorsearch pop pop /post exch def s 4 122 put post ( cz) eq");
|
||||
check("/s (xx12 34) def s 2 5 getinterval token pop pop /post exch def s 5 57 put post token pop exch pop 94 eq");
|
||||
}
|
||||
|
||||
/// `token` on a string, `search` and `anchorsearch` copy neither string.
|
||||
#[test]
|
||||
fn token_and_search_copy_no_string() {
|
||||
for (src, op) in [
|
||||
("(12 34 56 78)", Op::Token),
|
||||
("(abc def ghi) ( )", Op::Search),
|
||||
("(abc def ghi) (xyz)", Op::Search),
|
||||
("(abc def ghi) (abc)", Op::AnchorSearch),
|
||||
("(abc def ghi) (def)", Op::AnchorSearch),
|
||||
] {
|
||||
let mut it = after(src.as_bytes());
|
||||
VALUES_COPIED.with(|n| n.set(0));
|
||||
assert_eq!(it.op(op), Ok(()), "{src} {op:?}");
|
||||
assert_eq!(VALUES_COPIED.with(std::cell::Cell::get), 0, "{src} {op:?}");
|
||||
it.release();
|
||||
}
|
||||
}
|
||||
|
||||
/// The median of `runs`.
|
||||
fn median(runs: &[Duration]) -> Duration {
|
||||
let mut sorted = runs.to_vec();
|
||||
sorted.sort();
|
||||
sorted.get(sorted.len() / 2).copied().unwrap_or_default()
|
||||
}
|
||||
|
||||
/// What a walk records of each result: a string's length and first bytes, any other object whole.
|
||||
fn mark(o: &Obj, h: &mut impl Hasher) {
|
||||
match o {
|
||||
Obj::Str(s) => {
|
||||
s.len().hash(h);
|
||||
s.borrow().iter().take(16).for_each(|b| b.hash(h));
|
||||
}
|
||||
o => format!("{o:?}").hash(h),
|
||||
}
|
||||
}
|
||||
|
||||
/// Walk `data` with `op` and `seek` (none for `token`) until the operator answers false, by copy
|
||||
/// or in place: how long it took, the calls made, and a hash of every result and of the operations
|
||||
/// spent. The interpreter is made before the clock starts.
|
||||
fn walk(data: &[u8], op: Op, seek: Option<&[u8]>, copy: bool) -> (Duration, usize, u64) {
|
||||
let mut it = after(b"");
|
||||
it.stack.push(Obj::Str(Shared::new(data.to_vec())));
|
||||
let mut calls = 0;
|
||||
let mut h = DefaultHasher::new();
|
||||
let start = Instant::now();
|
||||
loop {
|
||||
if let Some(seek) = seek {
|
||||
it.stack.push(Obj::Str(Shared::new(seek.to_vec())));
|
||||
}
|
||||
let r = if copy { by_copy(&mut it, op) } else { it.op(op) };
|
||||
assert_eq!(r, Ok(()));
|
||||
calls += 1;
|
||||
if !matches!(it.stack.pop(), Some(Obj::Bool(true))) {
|
||||
break;
|
||||
}
|
||||
let keep = it.stack.len() - if op == Op::Search { 2 } else { 1 };
|
||||
it.stack.iter().for_each(|o| mark(o, &mut h));
|
||||
it.stack.truncate(keep);
|
||||
}
|
||||
let took = start.elapsed();
|
||||
it.stack.iter().for_each(|o| mark(o, &mut h));
|
||||
it.ops_left().hash(&mut h);
|
||||
it.release();
|
||||
(took, calls, h.finish())
|
||||
}
|
||||
|
||||
/// Time both readers on `data` in 7 runs, alternating which goes first, check that they leave the
|
||||
/// same, and print every run and the medians.
|
||||
fn compare(what: &str, data: &[u8], op: Op, seek: Option<&[u8]>) {
|
||||
let (mut old, mut new) = (vec![], vec![]);
|
||||
let mut calls = 0;
|
||||
for run in 0..7 {
|
||||
let order: [bool; 2] = if run % 2 == 0 { [true, false] } else { [false, true] };
|
||||
let mut got = vec![];
|
||||
for copy in order {
|
||||
let (took, n, last) = walk(data, op, seek, copy);
|
||||
if copy {
|
||||
old.push(took)
|
||||
} else {
|
||||
new.push(took)
|
||||
}
|
||||
calls = n;
|
||||
got.push((n, last));
|
||||
}
|
||||
assert!(got.first() == got.get(1), "{what}: the readers differ");
|
||||
}
|
||||
let ms = |d: &Duration| format!("{:.2}", d.as_secs_f64() * 1000.0);
|
||||
println!("{what}: {} bytes, {calls} calls", data.len());
|
||||
println!(" by copy, ms: {}", old.iter().map(ms).collect::<Vec<_>>().join(" "));
|
||||
println!(" in place, ms: {}", new.iter().map(ms).collect::<Vec<_>>().join(" "));
|
||||
let (o, w) = (median(&old), median(&new));
|
||||
println!(" median: by copy {} ms, in place {} ms, {:.1}x", ms(&o), ms(&w), o.as_secs_f64() / w.as_secs_f64().max(1e-9));
|
||||
}
|
||||
|
||||
/// Times `token` and `search` walking a string by what each call leaves, against the copying
|
||||
/// reference readers, in one process: strings of 4 KiB, 64 KiB and 512 KiB, of numbers and names
|
||||
/// for `token` and of 128-byte lines for `search`. Run it in release:
|
||||
/// `cargo test --release -p vectorcraft-eps --lib tests_strings::string_walks_timed -- --ignored --nocapture`.
|
||||
#[test]
|
||||
#[ignore = "manual timing probe; wall-clock performance depends on machine load"]
|
||||
fn string_walks_timed() {
|
||||
for kib in [4, 64, 512] {
|
||||
let size = kib * 1024;
|
||||
let mut words = Vec::with_capacity(size + 16);
|
||||
let mut i = 0u32;
|
||||
while words.len() < size {
|
||||
let w = if i.is_multiple_of(2) { format!("{} ", i.wrapping_mul(2_654_435_761) % 100_000) } else { format!("/n{i} ") };
|
||||
words.extend_from_slice(w.as_bytes());
|
||||
i += 1;
|
||||
}
|
||||
compare(&format!("token, {kib} KiB"), &words, Op::Token, None);
|
||||
let lines: Vec<u8> = (0..size / 128).flat_map(|i| format!("{:<127}\n", format!("line {i}")).into_bytes()).collect();
|
||||
compare(&format!("search, {kib} KiB"), &lines, Op::Search, Some(b"\n"));
|
||||
}
|
||||
}
|
||||
@@ -2252,6 +2252,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
|
||||
- Import and export, later 2026-10-13 merges: SVGs that move objects with a CSS transform (`translate(100px, 0)`, `rotate(45deg)`) or style type with the `font` shorthand import as drawn (#1565); SVG symbols whose shapes use percentage lengths import at the size and place they are drawn, the percentages being of the symbol's `viewBox` (#1596); Inkscape's flowed text (`flowRoot`) opens as area type in its rectangle, a paragraph per `flowPara`, instead of being dropped, and a region that can't be read is left out with a warning (#1569, fixes #1568); the warning for an unsupported SVG filter names the filter, its primitives and the object, and says the object is drawn without it (#1599, fixes #1598); the pages of an Inkscape multi-page SVG become artboards, named by their labels (#1603, fixes #1601); SVG export with CSS classes or style entities stays fast in documents with many distinct styles (#1567); PDF and `.ai` import: evenly letter-spaced or tightened type on a path keeps its length along the path instead of closing up to the font's advances (#1586), and type on a path whose stroke is written glyph by glyph comes in as one text object with its stroke, not one object per glyph (#1585); the ICC profiles embedded in JPEG, TIFF and PSD exports have every tag on a 4-byte boundary (ICC.1 §7.1.2), so strict readers accept them (#1589, fixes #1584); GIF, PNG-8 and other indexed exports find each pixel's palette colour through an index instead of a scan, with identical output (#1576); a zero-length subpath draws its round cap as a dot and its projecting cap as a square, so dots in imported `.ai` and SVG files show (#1619, fixes #1613).
|
||||
- Files and untrusted input, 2026-10-14 merges: EPS import: a stitched shading keeps its hard colour changes (#1654, #1653). WMF/EMF import refuses an oversized embedded PNG or JPEG from its header, before any pixels are decoded (#1776). PDF open no longer takes exponential time on a crafted name tree with shared nodes when it looks for the editing data (#1781). The size limits on a native file's embedded data also apply to files read from memory, not only streamed ones (#1783). Saving over a private file on Unix no longer leaves a readable temporary copy beside it while the file is written (#1778). An Export for Screens suffix can no longer place files outside the export folder (#1777). Package refuses a folder where it would overwrite the open document or one of its linked files (#1786). ruzstd 0.9.1 fixes a decompression bomb (RUSTSEC-2026-0344) reachable from EPS/`.ai` and Affinity import (#1807). File Info dates are stamped only after a save succeeds, so a failed save no longer changes them (#1774). Linked files that change during a drag are updated after the drag instead of being missed (#1773).
|
||||
- EPS import: `readhexstring` and `readline` read the data left in a file in one pass instead of one byte per call, with the same bytes, result and next unread byte as before (about nine times less reader time on 6 MB of hex image data and on 8 MB of lines).
|
||||
- EPS import: `token` on a string, `search` and `anchorsearch` read their strings in place instead of copying the rest of the string on each call, with the same results, errors and operation count as before. Walking a 512 KiB string by what each call leaves takes 16 ms instead of 518 ms with `token` and 1.0 ms instead of 27 ms with `search`, and a 64 KiB string 2.2 ms instead of 10 ms with `token`; on a 4 KiB string the difference is under 0.1 ms (release build on Linux under load from other builds, median of 7 alternating runs, `cargo test --release -p vectorcraft-eps --lib tests_strings::string_walks_timed -- --ignored --nocapture`).
|
||||
- **Fields, search and window, 2026-10-14 merges:** Fields commit what was typed when you click away or move to another field, as Enter does; Escape still discards it (#1787). Up and Down move through the command search results and Enter runs the highlighted one (#1798, #1757). Slider rails show on Medium Dark (#1808, #1662). On Windows the custom title bar's window stays truly borderless, so the pointer lines up with what is drawn on systems where the hidden caption offset it (#1791, #1758; awaiting the reporter's confirmation).
|
||||
- **Tools, panels and type, later 2026-10-14 merges:** the Transform panel's, Properties panel's and Control bar's X, Y, W and H show and edit the bounds of the anchor points selected with Direct Selection, and a whole-object selection is unchanged (#1839, fixes #1824). With Snap to Grid on, anchors and objects snap to the grid even when Snap to Pixel is also ticked: the grid wins (#1840; #1816 stays open until the reporter confirms). A marquee with the Selection or Direct Selection tool also selects the unlocked ruler guides it crosses (#1836). The toolbar shows no group labels by default (a preference brings them back) and runs on in one or two columns; the All Tools drawer lists the tools by flyout group with their shortcuts, has a menu (Reset, Basic, Advanced) and a Show section for the Fill/Stroke, Coloring, Draw Mode and Screen Mode controls (`toolbar.show`, #1751). An action clicked in the Actions panel stays selected, so Play Current Selection and Delete Selection act on it (#1853, part of #1629; editing actions and action shortcuts remain). Redo pressed during a drag keeps the drag as a step instead of losing the redone edit (#1856, #1719). Preferences are written as soon as OK is pressed, so they survive a session that doesn't end with a normal quit (#1857; #1747 stays open until the reporter confirms). New and Redefine Character Style take the format of the selected text range, also while typing (#1634). Type inside symbols, pattern tiles, graph designs and opacity masks gets its layout bounds back when a native file opens, so warped type in a symbol looks the same after save and reopen (#1833, #1738). Editing, renaming, deleting or merging a global swatch reaches the art of opacity masks, and a swatch used only in a mask is no longer listed as unused (#1830, #1735). On macOS, Save As, Save a Copy and the first Save show their sheet again; the Format menu on the sheet (#866) is withdrawn until the format can be set before the sheet opens, and #866 is open again (#1855; #1800, #1831 and #1518 stay open until confirmed on a Mac).
|
||||
- **Files and untrusted input, later 2026-10-14 merges:** SVG import applies style sheet rules with `:not()` selectors, with their nesting bounded (#1799, #1557), no longer stalls on a style sheet with many stacked descendant selectors over deep nesting (#1834, #1703), and reads an SVG's linked files within the automation roots in force again (#1870). DXF export writes the VPORT record's view direction once (group code 36 was written twice, which strict readers reject, #1789). A deeply nested file no longer overflows the stack: nesting is capped at 32 objects (deeper groups are merged with a warning; SVG past 256 elements and PDF past 256 nested arrays are refused), symbols and patterns that use themselves open without the offending instance or paint, and a document nested more than about 40 deep can no longer be saved to a file that won't open again (#1852). PDF and `.ai` files nested deeply inside compressed streams, page trees holding themselves and functions or colour spaces built on themselves no longer crash the app (hayro 0.8; the import runs on a 16 MB thread, #1871); a decompression bomb or impossible predictor parameters are refused (#1873, #1700, #1701); a brush whose art draws the brush again through a symbol or pattern no longer crashes the app, and graph designs, Affinity, DXF, metafiles and plug-ins were probed with hostile input (#1872). Hostile EPS, Affinity and native files can no longer run memory or CPU away through ASCII85 data, PostScript objects holding themselves, flat-colour pixel layers or far and overlapping data offsets (#1863: #1715, #1714, #1704, #1699), and the save fallback for folders that refuse a rename keeps the old file's content until the new one is in (#1695). A file whose ids sit at their largest value no longer breaks new objects (#1718); a failed `command.batch` puts each document back whole, its file, history and a drag in progress included (#1697); a control request that timed out before the app took it never runs later, and the reply says which case it was (#1725, [control-protocol.md](control-protocol.md)); the Eyedropper and recolouring refuse an image too large as RGBA before decoding it (#1717) (all #1862). A save or export that fails is reported in a dialog that names the file and stays until closed, with the document left modified and the old file untouched (#1685); a browser download that can't start fails the save instead of marking it saved (#1693); a file that finishes opening waits while a dialog is open, so Save As options can't save the wrong document (#1694) (all #1865). krilla is built without its text shaping, so the unmaintained rustybuzz and ttf-parser don't ship (#1874, #1730); the CI gate compiles the web app for wasm, and the web's SVG nesting cap (34) follows from its 1 MiB stack (#1875).
|
||||
|
||||
Reference in New Issue
Block a user