Struct EarleyParser 

pub struct EarleyParser { /* private fields */ }

The Earley parser. Drives grammar matching: it keeps the set of Earley items, advances them byte-by-byte, and supports push/rollback of parser state for the matcher’s token rollback.

Implementations

impl EarleyParser

pub fn acceptable_byte_ranges(&self) -> Vec<(u8, u8)>

All byte ranges acceptable as the next input, across every latest scanable state. Ranges may overlap and are unsorted.

pub fn acceptable_byte_mask(&self) -> [bool; 256]

A 256-entry bitmap: out[b] is true if byte b can be the next input. This is the exact acceptable-next-byte set.

pub fn can_accept(&self, ch: u8) -> bool

True if byte ch can be accepted as the next input without mutating the parser. Note: for negative character classes this is a conservative pre-check; advance is authoritative.

impl EarleyParser

pub fn new( grammar: Arc<GrammarData>, initial_state: ParserState, need_expand: bool, ) -> Self

Construct a parser for grammar, seeding it with initial_state (or the root state when initial_state is the invalid sentinel). When need_expand is false the initial state is only placed in the scanable history — no predict/complete is run.

Panics if the grammar is not optimized (matches the C++ XGRAMMAR_LOG(FATAL) contract — the FSM-accelerated parser requires per_rule_fsms).

pub fn from_grammar(grammar: Arc<GrammarData>) -> Self

Build a parser seeded with the grammar’s root rule.

pub fn is_completed(&self) -> bool

True if the root rule has completed at the current input position — i.e. the stop token may be emitted now.

pub fn latest_scanable_states(&self) -> &[ParserState]

The scanable states reached at the current input position.

pub fn num_steps(&self) -> usize

Number of input positions currently recorded (history depth).

pub fn advance(&mut self, ch: u8) -> bool

Advance every scanable state by input byte ch.

Returns true if ch is accepted by at least one state. When ch is rejected the parser state is left unchanged, so the caller may safely try another byte.

impl EarleyParser

pub fn pop_last_states(&mut self, count: usize)

Remove the last count input positions — the rollback used by the matcher to undo speculatively-consumed tokens. Advancing count bytes then pop_last_states(count) restores the exact prior state.

Panics if count would empty the history (the first step is the initial state and must remain — matches the C++ FATAL check).

pub fn push_state_and_expand(&mut self, state: ParserState)

Push state into the parser and run predict/complete on it, recording the resulting scanable states as a new input position.

pub fn push_one_state_to_check(&mut self, state: ParserState)

Push one state as an extra history step that only checks whether it can accept a token — used by the matcher to probe a candidate without running prediction/completion. Pop it with pop_last_states(1).

pub fn reset(&mut self)

Reset the parser to a fresh parse of the grammar’s root rule.

Trait Implementations

impl Debug for EarleyParser

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.