use crate::parser::{is_delimiter, is_ws, Parser};
use crate::{Dictionary, Error, Object, Result};
#[derive(Debug, Clone, PartialEq)]
pub enum ContentToken {
Op {
operands: Vec<Object>,
operator: Vec<u8>,
},
InlineImage { dict: Dictionary, data: Vec<u8> },
Comment(Vec<u8>),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct ContentParseOptions {
pub keep_comments: bool,
}
pub struct ContentStreamParser<'a> {
input: &'a [u8],
pos: usize,
options: ContentParseOptions,
operands: Vec<Object>,
done: bool,
}
impl<'a> ContentStreamParser<'a> {
pub fn new(input: &'a [u8]) -> Self {
Self::with_options(input, ContentParseOptions::default())
}
pub fn with_options(input: &'a [u8], opts: ContentParseOptions) -> Self {
Self {
input,
pos: 0,
options: opts,
operands: Vec::new(),
done: false,
}
}
fn peek(&self) -> Option<u8> {
self.input.get(self.pos).copied()
}
fn peek_at(&self, offset: usize) -> Option<u8> {
self.input.get(self.pos + offset).copied()
}
fn skip_ws_collect_comment(&mut self) -> Option<Vec<u8>> {
loop {
while matches!(self.peek(), Some(byte) if is_ws(byte)) {
self.pos += 1;
}
if self.peek() == Some(b'%') {
let start = self.pos + 1;
while !matches!(self.peek(), None | Some(b'\n' | b'\r')) {
self.pos += 1;
}
if self.options.keep_comments {
return Some(self.input[start..self.pos].to_vec());
}
continue;
}
return None;
}
}
fn read_keyword(&mut self) -> Vec<u8> {
let start = self.pos;
while let Some(byte) = self.peek() {
if is_ws(byte) || is_delimiter(byte) {
break;
}
self.pos += 1;
}
self.input[start..self.pos].to_vec()
}
fn at_operand_start(&self) -> bool {
match self.peek() {
None => false,
Some(byte) => match byte {
b'/' | b'(' | b'[' => true,
b'<' => true, b'+' | b'-' | b'.' | b'0'..=b'9' => true,
b't' => self.keyword_operand(b"true"),
b'f' => self.keyword_operand(b"false"),
b'n' => self.keyword_operand(b"null"),
_ => false,
},
}
}
fn keyword_operand(&self, kw: &[u8]) -> bool {
let rest = &self.input[self.pos..];
rest.starts_with(kw)
&& match rest.get(kw.len()) {
None => true,
Some(b) => is_ws(*b) || is_delimiter(*b),
}
}
fn parse_operand(&mut self) -> Result<Object> {
let mut parser = Parser::new_no_reference(&self.input[self.pos..]);
let obj = parser.parse_one_object()?;
self.pos += parser.position();
Ok(obj)
}
fn skip_ws_and_comments(&mut self) {
while self.skip_ws_collect_comment().is_some() {}
}
fn parse_inline_image(&mut self) -> Result<ContentToken> {
let mut dict = Dictionary::new();
loop {
self.skip_ws_and_comments();
match self.peek() {
None => {
return Err(Error::parse(self.pos, "inline image missing ID"));
}
Some(b'/') => {
let mut parser = Parser::new_no_reference(&self.input[self.pos..]);
let key = match parser.parse_one_object()? {
Object::Name(name) => name,
_ => return Err(Error::parse(self.pos, "inline image key is not a name")),
};
self.pos += parser.position();
self.skip_ws_and_comments();
let value = self.parse_operand()?;
dict.insert(key, value);
}
Some(_) => {
let kw = self.read_keyword();
if kw == b"ID" {
break;
}
return Err(Error::parse(
self.pos,
format!(
"unexpected token {:?} in inline image header",
String::from_utf8_lossy(&kw)
),
));
}
}
}
match self.peek() {
Some(b'\r') if self.peek_at(1) == Some(b'\n') => self.pos += 2,
Some(byte) if is_ws(byte) => self.pos += 1,
_ => {}
}
let data_start = self.pos;
loop {
match self.peek() {
None => {
return Err(Error::parse(self.pos, "inline image missing EI"));
}
Some(b'E') if self.peek_at(1) == Some(b'I') => {
let prev_ok = self.pos == data_start
|| self.input.get(self.pos - 1).is_some_and(|b| is_ws(*b));
let after = self.peek_at(2);
let after_ok = after.is_none_or(|b| is_ws(b) || is_delimiter(b));
if prev_ok && after_ok {
let mut data_end = self.pos;
if data_end >= data_start + 2
&& self.input.get(data_end - 2) == Some(&b'\r')
&& self.input.get(data_end - 1) == Some(&b'\n')
{
data_end -= 2;
} else if data_end > data_start
&& self.input.get(data_end - 1).is_some_and(|b| is_ws(*b))
{
data_end -= 1;
}
let data = self.input[data_start..data_end].to_vec();
self.pos += 2; return Ok(ContentToken::InlineImage { dict, data });
}
self.pos += 1;
}
Some(_) => self.pos += 1,
}
}
}
fn next_token(&mut self) -> Option<Result<ContentToken>> {
loop {
if let Some(comment) = self.skip_ws_collect_comment() {
return Some(Ok(ContentToken::Comment(comment)));
}
if self.peek().is_none() {
if self.operands.is_empty() {
return None;
}
return Some(Err(Error::parse(
self.pos,
"content stream ended with dangling operands",
)));
}
if self.at_operand_start() {
match self.parse_operand() {
Ok(obj) => {
self.operands.push(obj);
continue;
}
Err(err) => return Some(Err(err)),
}
}
let keyword = self.read_keyword();
if keyword.is_empty() {
return Some(Err(Error::parse(
self.pos,
"unexpected delimiter in content stream",
)));
}
if keyword == b"BI" {
if !self.operands.is_empty() {
return Some(Err(Error::parse(
self.pos,
"inline image operator BI cannot have operands",
)));
}
return Some(self.parse_inline_image());
}
let operands = std::mem::take(&mut self.operands);
return Some(Ok(ContentToken::Op {
operands,
operator: keyword,
}));
}
}
}
impl<'a> Iterator for ContentStreamParser<'a> {
type Item = Result<ContentToken>;
fn next(&mut self) -> Option<Self::Item> {
if self.done {
return None;
}
let item = self.next_token();
if matches!(item, Some(Err(_)) | None) {
self.done = true;
}
item
}
}
pub fn normalize_content_stream(input: &[u8]) -> Result<Vec<u8>> {
let mut out = Vec::with_capacity(input.len());
for token in ContentStreamParser::new(input) {
match token? {
ContentToken::Op { operands, operator } => {
for (i, operand) in operands.iter().enumerate() {
if i > 0 {
out.push(b' ');
}
operand.write_pdf(&mut out);
}
if !operands.is_empty() {
out.push(b' ');
}
out.extend_from_slice(&operator);
out.push(b'\n');
}
ContentToken::InlineImage { dict, data } => {
out.extend_from_slice(b"BI\n");
for (key, value) in dict.iter() {
out.extend_from_slice(b" /");
out.extend_from_slice(key);
out.push(b' ');
value.write_pdf(&mut out);
out.push(b'\n');
}
out.extend_from_slice(b"ID\n");
out.extend_from_slice(&data);
out.push(b'\n');
out.extend_from_slice(b"EI\n");
}
ContentToken::Comment(_) => {
}
}
}
Ok(out)
}