diff --git a/Cargo.lock b/Cargo.lock index 3a91211871..d780911c11 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1224,6 +1224,14 @@ dependencies = [ "thiserror 2.0.21", ] +[[package]] +name = "craft-plotter" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=9101c4fc226f5f111b5a890a6c5c19bf3991fd76#9101c4fc226f5f111b5a890a6c5c19bf3991fd76" +dependencies = [ + "thiserror 2.0.21", +] + [[package]] name = "craft-print" version = "0.1.0" @@ -6720,6 +6728,7 @@ version = "0.24.1" dependencies = [ "craft-dxf", "craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=a499742a9389f47d10cdc61e4cdbf4e5f07f48cd)", + "craft-plotter", "image", "kurbo 0.13.1", "serde_json", diff --git a/Cargo.toml b/Cargo.toml index e246dbf705..891cce208d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -32,6 +32,7 @@ craft-mime = { git = "https://github.com/storytold/craft-libs", rev = "a499742a9 # EPS container, previews, ASCII85 and DSC comments (craft-libs#778). craft-eps = { git = "https://github.com/storytold/craft-libs", rev = "a499742a9389f47d10cdc61e4cdbf4e5f07f48cd" } # DXF tags, reader and writer (craft-libs#778, #926, #927). +craft-plotter = { git = "https://github.com/storytold/craft-libs", rev = "9101c4fc226f5f111b5a890a6c5c19bf3991fd76" } craft-dxf = { git = "https://github.com/storytold/craft-libs", rev = "a499742a9389f47d10cdc61e4cdbf4e5f07f48cd" } # WMF, EMF and EMF+ reader (craft-libs#778). craft-metafile = { git = "https://github.com/storytold/craft-libs", rev = "a499742a9389f47d10cdc61e4cdbf4e5f07f48cd" } diff --git a/crates/cad/Cargo.toml b/crates/cad/Cargo.toml index f2f9158730..1cbf8dc431 100644 --- a/crates/cad/Cargo.toml +++ b/crates/cad/Cargo.toml @@ -10,6 +10,7 @@ workspace = true [dependencies] craft-dxf = { workspace = true } +craft-plotter = { workspace = true } vectorcraft-geom = { workspace = true } vectorcraft-color = { workspace = true } vectorcraft-doc = { workspace = true } diff --git a/crates/cad/src/hpgl/lex.rs b/crates/cad/src/hpgl/lex.rs index 5025d07c6f..cc9b8b5efe 100644 --- a/crates/cad/src/hpgl/lex.rs +++ b/crates/cad/src/hpgl/lex.rs @@ -1,428 +1,2 @@ -//! The bytes of an HP-GL file as instructions: two-letter mnemonics and the parameters that follow -//! them, read one at a time as the plot asks for them. Printer escape sequences (PCL, HP RTL, the -//! HP-GL device-control escapes) and PJL lines around and between the instructions are skipped, -//! with the data their escapes carry. - -/// The end-of-text character, the default label terminator. -pub(super) const ETX: u8 = 3; -const ESC: u8 = 0x1b; - -/// The most digits of a number that count: longer ones are read as their first digits. -const MAX_DIGITS: usize = 18; - -/// What the bytes being read hold. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -enum Mode { - /// HP-GL instructions. - Hpgl, - /// PCL or HP RTL: escape sequences and their data, nothing to draw. - Pcl, - /// After a Universal Exit Language: PJL lines until a language starts. - Pjl, -} - -/// One item of a PE (Polyline Encoded) instruction. -#[derive(Clone, Copy, Debug, PartialEq)] -pub(super) enum PeItem { - /// Select pen. - Pen(i64), - /// Rectangle mode: the following coordinates come in fours. - Rect, - /// A coordinate pair, after a pen-up flag (`up`) and an absolute flag (`absolute`). - Point { x: f64, y: f64, up: bool, absolute: bool }, -} - -/// The state of one PE instruction being read. -#[derive(Clone, Copy, Debug, Default)] -pub(super) struct Pe { - seven_bit: bool, - fraction_bits: u32, - up: bool, - absolute: bool, -} - -pub(super) struct Lexer<'a> { - b: &'a [u8], - at: usize, - mode: Mode, - /// The file holds HP RTL or PCL raster image data. - pub raster: bool, -} - -/// Is `c` a byte that separates numeric parameters (or white space between instructions)? -fn separator(c: u8) -> bool { - matches!(c, b' ' | b',' | b'\t' | b'\r' | b'\n' | 0) -} - -impl<'a> Lexer<'a> { - pub fn new(b: &'a [u8]) -> Self { - Self { b, at: 0, mode: Mode::Hpgl, raster: false } - } - - fn peek(&self) -> Option { - self.b.get(self.at).copied() - } - - /// Whether everything has been read. - pub fn done(&self) -> bool { - self.at >= self.b.len() - } - - /// How many bytes have been read. - pub fn pos(&self) -> usize { - self.at - } - - /// The next instruction's mnemonic, in upper case; `strict`: only white space, semicolons and - /// escape sequences may come before it (anything else gives `None`, as the end does). - pub fn op(&mut self, strict: bool) -> Option<[u8; 2]> { - loop { - let c = self.peek()?; - if c == ESC { - self.escape(); - continue; - } - match self.mode { - Mode::Pcl => { - self.at += 1; - continue; - } - Mode::Pjl => { - if separator(c) { - self.at += 1; - } else if c == b'@' { - self.pjl_line(); - } else { - self.mode = Mode::Hpgl; - } - continue; - } - Mode::Hpgl => {} - } - let next = self.b.get(self.at + 1).copied(); - if c.is_ascii_alphabetic() - && let Some(n) = next.filter(u8::is_ascii_alphabetic) - { - self.at += 2; - return Some([c.to_ascii_uppercase(), n.to_ascii_uppercase()]); - } - if strict && !(separator(c) || c == b';' || c < 0x20) { - return None; - } - self.at += 1; - } - } - - /// One `@PJL` line: an `ENTER LANGUAGE` command picks what follows. - fn pjl_line(&mut self) { - let rest = &self.b[self.at..]; - let end = rest.iter().position(|&c| c == b'\n').map_or(rest.len(), |n| n + 1); - // A command names its language within its first 256 bytes; longer lines aren't copied. - let line = String::from_utf8_lossy(&rest[..end.min(256)]).to_ascii_uppercase(); - if let Some(lang) = line.split_once("LANGUAGE").map(|(_, l)| l.trim_start_matches([' ', '=']).trim()) { - self.mode = if lang.starts_with("HPGL") { Mode::Hpgl } else { Mode::Pcl }; - } - self.at += end; - } - - /// An escape sequence at the current byte, with the data it carries. - fn escape(&mut self) { - self.at += 1; - let Some(c) = self.peek() else { return }; - self.at += 1; - match c { - // Universal Exit Language (`ESC%-12345X`) and the language switches (`ESC%#B` to HP-GL, - // `ESC%#A` to PCL or HP RTL). - b'%' => { - let (_, end) = self.value(); - match end { - Some(b'X') => self.mode = Mode::Pjl, - Some(b'B') => self.mode = Mode::Hpgl, - Some(b'A') => self.mode = Mode::Pcl, - _ => {} - } - } - // Reset: PCL follows, until a language switch. - b'E' => self.mode = Mode::Pcl, - // HP-GL device control: `ESC.` and a letter, with parameters up to a colon. - b'.' => { - let Some(kind) = self.peek() else { return }; - self.at += 1; - if !b"()YZBEJKLORUX".contains(&kind) { - let rest = &self.b[self.at..self.b.len().min(self.at + 80)]; - if let Some(n) = rest.iter().position(|&c| c == b':') - && rest[..n].iter().all(|c| c.is_ascii_digit() || matches!(c, b';' | b' ' | b',')) - { - self.at += n + 1; - } - } - } - // Parameterized PCL: a group character, then values each ending in a letter (upper case - // ends the sequence); `W`, `*b…V` (raster data by plane) and `&p…X` (transparent print - // data) are followed by that many bytes of data. Without a group character (`ESC(8U`, - // `ESC)0N`), one value and the letter ending it. - 0x21..=0x2f => { - let Some(group) = self.peek().filter(|g| (0x60..=0x7e).contains(g)) else { - self.value(); - return; - }; - self.at += 1; - loop { - let (v, end) = self.value(); - let Some(end) = end else { return }; - let upper = end.to_ascii_uppercase(); - if upper == b'W' || (c, group, upper) == (b'*', b'b', b'V') || (c, group, upper) == (b'&', b'p', b'X') { - let n = v.max(0.0).min((self.b.len() - self.at) as f64) as usize; - if (c, group) == (b'*', b'b') && n > 0 { - self.raster = true; - } - self.at += n; - } - if (c, group, end) == (b'*', b'r', b'A') { - self.raster = true; - } - if !end.is_ascii_lowercase() { - return; - } - } - } - // A two-character escape. - _ => {} - } - } - - /// A PCL value (`[+-]digits[.digits]`, any part missing) and the character that ends it; `None` - /// when that is not a letter or `@` (which is then left unread). - fn value(&mut self) -> (f64, Option) { - let v = self.number_here().unwrap_or(0.0); - match self.peek() { - Some(c) if c.is_ascii_alphabetic() || c == b'@' => { - self.at += 1; - (v, Some(c)) - } - _ => (v, None), - } - } - - /// A number starting at the current byte (`[+-]digits[.digits]`), `None` when it has no digit - /// (its sign and point are read all the same). - fn number_here(&mut self) -> Option { - let mut neg = false; - if let Some(c @ (b'+' | b'-')) = self.peek() { - neg = c == b'-'; - self.at += 1; - } - let (mut v, mut digits, mut scale) = (0.0f64, 0usize, 1.0f64); - let mut point = false; - while let Some(c) = self.peek() { - if c.is_ascii_digit() { - if digits < MAX_DIGITS { - if point { - scale /= 10.0; - v += f64::from(c - b'0') * scale; - } else { - v = v * 10.0 + f64::from(c - b'0'); - } - } else if !point { - // Past the digits that count, an integer part keeps its size. - v *= 10.0; - } - digits += 1; - } else if c == b'.' && !point { - point = true; - } else { - break; - } - self.at += 1; - } - let v = v.min(f64::MAX); - (digits > 0).then_some(if neg { -v } else { v }) - } - - /// The next numeric parameter of the instruction being read, or `None` at its end (a semicolon - /// ending it is read). - pub fn number(&mut self) -> Option { - loop { - let c = self.peek()?; - if separator(c) { - self.at += 1; - } else if c.is_ascii_digit() || matches!(c, b'+' | b'-' | b'.') { - if let Some(v) = self.number_here() { - return Some(v); - } - } else { - if c == b';' { - self.at += 1; - } - return None; - } - } - } - - /// Up to `out.len()` numeric parameters into `out` (the rest are read and dropped) → how many. - pub fn numbers(&mut self, out: &mut [f64]) -> usize { - let mut n = 0; - while let Some(v) = self.number() { - if let Some(slot) = out.get_mut(n) { - *slot = v; - } - n += 1; - } - n.min(out.len()) - } - - /// Read and drop the parameters of the instruction being read: numbers and quoted strings. - pub fn params(&mut self) { - loop { - while self.number().is_some() {} - if self.peek() != Some(b'"') { - return; - } - self.quoted(); - } - } - - /// Read and drop numeric parameters → whether a semicolon ended them (an instruction the reader - /// doesn't know, written out in full). - pub fn closed_params(&mut self) -> bool { - while self.number().is_some() {} - self.at > 0 && self.b.get(self.at - 1) == Some(&b';') - } - - /// A comment (CO): its quoted string or nothing, then the terminator or the end → whether it - /// is one. - pub fn comment(&mut self) -> bool { - while self.peek().is_some_and(separator) { - self.at += 1; - } - match self.peek() { - Some(b'"') => self.quoted(), - Some(b';') => { - self.at += 1; - true - } - None => true, - Some(_) => false, - } - } - - /// The text of a label, up to and including `terminator` (or the end). - pub fn label(&mut self, terminator: u8) { - let rest = &self.b[self.at..]; - self.at += rest.iter().position(|&c| c == terminator).map_or(rest.len(), |n| n + 1); - } - - /// A quoted string (CO): the parameters up to its closing quote, then the terminator → whether - /// there was one. - pub fn quoted(&mut self) -> bool { - while self.peek().is_some_and(separator) { - self.at += 1; - } - let found = self.peek() == Some(b'"'); - if found { - self.at += 1; - let rest = &self.b[self.at..]; - self.at += rest.iter().position(|&c| c == b'"').map_or(rest.len(), |n| n + 1); - } - if self.peek() == Some(b';') { - self.at += 1; - } - found - } - - /// The character right after the mnemonic (DT, SM), `None` when it is a semicolon or the end - /// (the semicolon is read). - pub fn char(&mut self) -> Option { - let c = self.peek()?; - self.at += 1; - (c != b';').then_some(c) - } - - /// The next item of a PE instruction, `None` at its end (its semicolon is read). - pub fn pe(&mut self, st: &mut Pe) -> Option { - loop { - let raw = self.peek()?; - let c = raw & 0x7f; - // Spaces, deletes, control characters and bytes 128 to 160 and 255 are ignored. - if raw <= 32 || raw == 127 || (128..=160).contains(&raw) || raw == 255 { - self.at += 1; - continue; - } - match c { - b';' => { - self.at += 1; - return None; - } - // Flags keep their meaning with the eighth bit set; digits are 63 and up (191 and up). - b':' | b'<' | b'>' | b'=' | b'7' | b'9' if raw < 63 || (0xb7..191).contains(&raw) => { - self.at += 1; - match c { - b':' => return self.pe_value(st).map(PeItem::Pen).or_else(|| self.end_pe()), - b'<' => st.up = true, - b'>' => match self.pe_value(st) { - Some(n) => st.fraction_bits = n.clamp(0, 52) as u32, - None => return self.end_pe(), - }, - b'=' => st.absolute = true, - b'7' => st.seven_bit = true, - _ => return Some(PeItem::Rect), - } - } - _ => { - let scale = 0.5f64.powi(st.fraction_bits as i32); - let (Some(x), Some(y)) = (self.pe_value(st), self.pe_value(st)) else { return self.end_pe() }; - let item = PeItem::Point { x: x as f64 * scale, y: y as f64 * scale, up: st.up, absolute: st.absolute }; - (st.up, st.absolute) = (false, false); - return Some(item); - } - } - } - } - - /// The rest of a PE instruction that can't be decoded: see [`Lexer::skip_pe`]. - fn end_pe(&mut self) -> Option { - self.skip_pe(); - None - } - - /// The data of a PE instruction, up to and including its semicolon, unread: its data is never - /// read as instructions. - pub fn skip_pe(&mut self) { - let rest = &self.b[self.at..]; - self.at += rest.iter().position(|&c| c == b';').map_or(rest.len(), |n| n + 1); - } - - /// One encoded PE number, `None` when the instruction ends inside it (or a byte that is no - /// digit comes first, which is read). - fn pe_value(&mut self, st: &Pe) -> Option { - let (base, low, high): (u64, std::ops::RangeInclusive, std::ops::RangeInclusive) = - if st.seven_bit { (32, 63..=94, 95..=126) } else { (64, 63..=126, 191..=254) }; - let (mut v, mut place) = (0u64, 1u64); - loop { - let raw = self.peek()?; - let c = if st.seven_bit { raw & 0x7f } else { raw }; - if raw <= 32 || raw == 127 || (128..=160).contains(&raw) || raw == 255 { - self.at += 1; - continue; - } - if c == b';' { - return None; - } - self.at += 1; - let (digit, last) = if low.contains(&c) { - (u64::from(c - 63), false) - } else if high.contains(&c) { - (u64::from(c - high.start()), true) - } else { - return None; - }; - v = v.saturating_add(digit.saturating_mul(place)); - place = place.saturating_mul(base); - if last { - // The low bit is the sign. - let n = i64::try_from(v >> 1).unwrap_or(i64::MAX); - return Some(if v & 1 == 1 { -n } else { n }); - } - } - } -} +//! Shared HP-GL byte lexer; drawing interpretation remains local. +pub(super) use craft_plotter::hpgl::lex::{ETX, Lexer, Pe, PeItem};