mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-22 18:41:27 +01:00
A literal string's octal escape was converted with `u8::from_str_radix`, which fails above 0o377, so the byte was dropped. Read one to three octal digits into a u16 (at most 0o777) and push the low byte, as ISO 32000-2 7.3.4.2 and the PostScript Language Reference (third edition, 3.2.2) specify: "high-order overflow shall be ignored". Escapes up to `\377` decode as before. Record the patch in SOURCE.json and vendor/README.craft-reader.md. Fixes #2321
304 lines
7.3 KiB
Rust
304 lines
7.3 KiB
Rust
mod ascii_85;
|
|
pub(crate) mod ascii_hex;
|
|
mod literal;
|
|
|
|
use alloc::vec::Vec;
|
|
|
|
use crate::error::{Error, Result};
|
|
use crate::reader::Reader;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum StringInner<'a> {
|
|
Literal(&'a [u8]),
|
|
Hex(&'a [u8]),
|
|
Ascii85(&'a [u8]),
|
|
}
|
|
|
|
/// A PostScript string object.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub struct String<'a> {
|
|
inner: StringInner<'a>,
|
|
}
|
|
|
|
impl<'a> String<'a> {
|
|
pub(crate) const fn from_literal(data: &'a [u8]) -> Self {
|
|
Self {
|
|
inner: StringInner::Literal(data),
|
|
}
|
|
}
|
|
|
|
pub(crate) const fn from_hex(data: &'a [u8]) -> Self {
|
|
Self {
|
|
inner: StringInner::Hex(data),
|
|
}
|
|
}
|
|
|
|
pub(crate) const fn from_ascii85(data: &'a [u8]) -> Self {
|
|
Self {
|
|
inner: StringInner::Ascii85(data),
|
|
}
|
|
}
|
|
|
|
/// Decode the string content into `out`, replacing any previous contents.
|
|
pub fn decode_into(&self, out: &mut Vec<u8>) -> Result<()> {
|
|
out.clear();
|
|
match self.inner {
|
|
StringInner::Literal(data) => literal::decode_into(data, out),
|
|
StringInner::Hex(data) => ascii_hex::decode_into(data, out),
|
|
StringInner::Ascii85(data) => ascii_85::decode_into(data, out),
|
|
}
|
|
.ok_or(Error::SyntaxError)
|
|
}
|
|
|
|
/// Decode the string content.
|
|
pub fn decode(&self) -> Result<Vec<u8>> {
|
|
let mut out = Vec::new();
|
|
self.decode_into(&mut out)?;
|
|
Ok(out)
|
|
}
|
|
}
|
|
|
|
pub(crate) fn parse_literal<'a>(r: &mut Reader<'a>) -> Option<&'a [u8]> {
|
|
let start = r.offset();
|
|
skip_literal(r)?;
|
|
let end = r.offset();
|
|
// Exclude outer parentheses.
|
|
r.range(start + 1..end - 1)
|
|
}
|
|
|
|
pub(crate) fn parse_hex<'a>(r: &mut Reader<'a>) -> Option<&'a [u8]> {
|
|
r.forward_tag(b"<")?;
|
|
let start = r.offset();
|
|
while let Some(b) = r.read_byte() {
|
|
if b == b'>' {
|
|
return r.range(start..r.offset() - 1);
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
pub(crate) fn parse_ascii85<'a>(r: &mut Reader<'a>) -> Option<&'a [u8]> {
|
|
r.forward_tag(b"<~")?;
|
|
let start = r.offset();
|
|
loop {
|
|
let b = r.read_byte()?;
|
|
if b == b'~' {
|
|
let end = r.offset() - 1;
|
|
r.forward_tag(b">")?;
|
|
return r.range(start..end);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn skip_literal(r: &mut Reader<'_>) -> Option<()> {
|
|
r.forward_tag(b"(")?;
|
|
let mut depth = 1_u32;
|
|
|
|
while depth > 0 {
|
|
let byte = r.read_byte()?;
|
|
match byte {
|
|
b'\\' => {
|
|
let _ = r.read_byte()?;
|
|
}
|
|
b'(' => depth += 1,
|
|
b')' => depth -= 1,
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
Some(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn decode_literal(input: &[u8]) -> Result<Vec<u8>> {
|
|
let mut r = Reader::new(input);
|
|
let data = parse_literal(&mut r).ok_or(Error::SyntaxError)?;
|
|
String::from_literal(data).decode()
|
|
}
|
|
|
|
#[test]
|
|
fn literal_empty() {
|
|
assert_eq!(decode_literal(b"()").unwrap(), b"");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_simple() {
|
|
assert_eq!(decode_literal(b"(Hello)").unwrap(), b"Hello");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_nested_parens() {
|
|
assert_eq!(
|
|
decode_literal(b"(Hi (()) there)").unwrap(),
|
|
b"Hi (()) there"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn literal_escape_n() {
|
|
assert_eq!(decode_literal(b"(a\\nb)").unwrap(), b"a\nb");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_escape_r() {
|
|
assert_eq!(decode_literal(b"(a\\rb)").unwrap(), b"a\rb");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_escape_t() {
|
|
assert_eq!(decode_literal(b"(a\\tb)").unwrap(), b"a\tb");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_escape_b() {
|
|
assert_eq!(decode_literal(b"(a\\bb)").unwrap(), &[b'a', 0x08, b'b']);
|
|
}
|
|
|
|
#[test]
|
|
fn literal_escape_f() {
|
|
assert_eq!(decode_literal(b"(a\\fb)").unwrap(), &[b'a', 0x0C, b'b']);
|
|
}
|
|
|
|
#[test]
|
|
fn literal_escape_backslash() {
|
|
assert_eq!(decode_literal(b"(a\\\\b)").unwrap(), b"a\\b");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_escape_parens() {
|
|
assert_eq!(decode_literal(b"(Hi \\()").unwrap(), b"Hi (");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_octal_three_digits() {
|
|
assert_eq!(decode_literal(b"(\\053)").unwrap(), b"+");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_octal_two_digits() {
|
|
assert_eq!(decode_literal(b"(\\36)").unwrap(), b"\x1e");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_octal_one_digit() {
|
|
assert_eq!(decode_literal(b"(\\3)").unwrap(), b"\x03");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_octal_overflow_keeps_the_low_eight_bits() {
|
|
assert_eq!(decode_literal(b"(\\737)").unwrap(), b"\xDF");
|
|
assert_eq!(decode_literal(b"(\\400\\777)").unwrap(), b"\x00\xFF");
|
|
assert_eq!(decode_literal(b"(\\1234)").unwrap(), b"S4");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_octal_short_escape_stops_at_a_non_octal_byte() {
|
|
assert_eq!(
|
|
decode_literal(b"(\\36a\\3z\\0089)").unwrap(),
|
|
b"\x1ea\x03z\x0089"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn literal_line_continuation_lf() {
|
|
assert_eq!(decode_literal(b"(Hi \\\nthere)").unwrap(), b"Hi there");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_line_continuation_cr() {
|
|
assert_eq!(decode_literal(b"(Hi \\\rthere)").unwrap(), b"Hi there");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_line_continuation_crlf() {
|
|
assert_eq!(decode_literal(b"(Hi \\\r\nthere)").unwrap(), b"Hi there");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_bare_eol_lf() {
|
|
assert_eq!(decode_literal(b"(a\nb)").unwrap(), b"a\nb");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_bare_eol_cr() {
|
|
assert_eq!(decode_literal(b"(a\rb)").unwrap(), b"a\nb");
|
|
}
|
|
|
|
#[test]
|
|
fn literal_bare_eol_crlf() {
|
|
assert_eq!(decode_literal(b"(a\r\nb)").unwrap(), b"a\nb");
|
|
}
|
|
|
|
fn decode_hex(input: &[u8]) -> Result<Vec<u8>> {
|
|
let mut r = Reader::new(input);
|
|
let data = parse_hex(&mut r).ok_or(Error::SyntaxError)?;
|
|
String::from_hex(data).decode()
|
|
}
|
|
|
|
#[test]
|
|
fn hex_simple() {
|
|
assert_eq!(decode_hex(b"<48656C6C6F>").unwrap(), b"Hello");
|
|
}
|
|
|
|
#[test]
|
|
fn hex_with_whitespace() {
|
|
assert_eq!(decode_hex(b"<48 65 6C 6C 6F>").unwrap(), b"Hello");
|
|
}
|
|
|
|
#[test]
|
|
fn hex_odd_nibble() {
|
|
assert_eq!(decode_hex(b"<ABC>").unwrap(), &[0xAB, 0xC0]);
|
|
}
|
|
|
|
#[test]
|
|
fn hex_empty() {
|
|
assert_eq!(decode_hex(b"<>").unwrap(), b"");
|
|
}
|
|
|
|
#[test]
|
|
fn hex_lowercase() {
|
|
assert_eq!(decode_hex(b"<abcd>").unwrap(), &[0xAB, 0xCD]);
|
|
}
|
|
|
|
#[test]
|
|
fn hex_mixed_case() {
|
|
assert_eq!(decode_hex(b"<aB3E>").unwrap(), &[0xAB, 0x3E]);
|
|
}
|
|
|
|
fn decode_a85(input: &[u8]) -> Result<Vec<u8>> {
|
|
let mut r = Reader::new(input);
|
|
let data = parse_ascii85(&mut r).ok_or(Error::SyntaxError)?;
|
|
String::from_ascii85(data).decode()
|
|
}
|
|
|
|
#[test]
|
|
fn ascii85_simple() {
|
|
// "Hello" in ASCII85 is "87cURDZ"
|
|
assert_eq!(decode_a85(b"<~87cURDZ~>").unwrap(), b"Hello");
|
|
}
|
|
|
|
#[test]
|
|
fn ascii85_empty() {
|
|
assert_eq!(decode_a85(b"<~~>").unwrap(), b"");
|
|
}
|
|
|
|
#[test]
|
|
fn ascii85_z_shorthand() {
|
|
assert_eq!(decode_a85(b"<~z~>").unwrap(), &[0, 0, 0, 0]);
|
|
}
|
|
|
|
#[test]
|
|
fn ascii85_partial_group() {
|
|
let result = decode_a85(b"<~87~>").unwrap();
|
|
assert_eq!(result.len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn ascii85_with_whitespace() {
|
|
assert_eq!(decode_a85(b"<~87cU RDZ~>").unwrap(), b"Hello");
|
|
}
|
|
}
|