Struct Lexer 

pub struct Lexer<R> { /* private fields */ }

PDF Lexer for tokenizing PDF content

Implementations

impl<R: Read> Lexer<R>

pub fn new(reader: R) -> Self

Create a new lexer from a reader with default options

pub fn new_with_options(reader: R, options: ParseOptions) -> Self

Create a new lexer from a reader with custom options

pub fn warnings(&self) -> &[ParseWarning]

Get warnings collected during lexing (if enabled)

pub fn next_token(&mut self) -> ParseResult<Token>

Get the next token

pub fn read_newline(&mut self) -> ParseResult<()>

Read a newline sequence (CR, LF, or CRLF)

pub fn peek_byte(&mut self) -> ParseResult<u8>

Read exactly n bytes Peek at the next byte without consuming it

pub fn read_byte(&mut self) -> ParseResult<u8>

Read a single byte

pub fn seek(&mut self, pos: u64) -> ParseResult<()>

where R: Seek,

Seek to a specific position

pub fn read_bytes(&mut self, n: usize) -> ParseResult<Vec<u8>>

pub fn read_until_sequence(&mut self, sequence: &[u8]) -> ParseResult<Vec<u8>>

Read until a specific byte sequence is found

pub fn position(&self) -> usize

Get current position

pub fn push_token(&mut self, token: Token)

Push back a token to be returned by the next call to next_token

pub fn expect_keyword(&mut self, keyword: &str) -> ParseResult<()>

Expect a specific keyword token

pub fn find_keyword_ahead( &mut self, keyword: &str, max_bytes: usize, ) -> ParseResult<Option<usize>>

where R: Seek,

Find a keyword ahead in the stream without consuming bytes Returns the number of bytes until the keyword is found

pub fn peek_ahead(&mut self, n: usize) -> ParseResult<Vec<u8>>

where R: Seek,

Peek ahead n bytes without consuming them

pub fn save_position(&mut self) -> ParseResult<(u64, Option<u8>)>

where R: Seek,

Save the current position for later restoration

pub fn restore_position(&mut self, saved: (u64, Option<u8>)) -> ParseResult<()>

where R: Seek,

Restore a previously saved position

pub fn peek_token(&mut self) -> ParseResult<Token>

where R: Seek,

Peek the next token without consuming it