Struct Recognizer 

pub struct Recognizer<'g, F = NullForest>
where
    F: Forest,
{
    pub forest: F,
    pub grammar: &'g InternalGrammar,
    /* private fields */
}

The recognizer implements the Earley algorithm. It parses the given input according to the grammar. The parse result is constructed inside the forest.

To save memory, it only retains those parts of the Earley table that may be useful in the future.

Fields

forest: F

grammar: &'g InternalGrammar

Implementations

impl<'g, F> Recognizer<'g, F>

where F: Forest,

pub fn trace(&self) -> Trace<'_, F::NodeRef>

pub fn events(&self) -> Events<'_, F::NodeRef>

pub fn minimal_distances(&self) -> Distances<'_, F::NodeRef>

pub fn expected_terminals(&self) -> ExpectedTerminals<'_, F::NodeRef>

impl<'g, F> Recognizer<'g, F>

where F: MemoryUse<Arg = &'g InternalGrammar> + Forest,

pub fn new_with_hint(grammar: &'g InternalGrammar, tokens: usize) -> Self

impl<'g, F> Recognizer<'g, F>

where F: Forest,

pub fn new(grammar: &'g InternalGrammar, forest: F) -> Recognizer<'g, F>

Creates a new recognizer for a given grammar and forest. The recognizer has an initial Earley set that predicts the grammar’s start symbol.

pub fn predict(&mut self, symbol: Symbol)

Makes the current Earley set predict a given symbol.

pub fn begin_earleme(&mut self)

pub fn scan(&mut self, symbol: Symbol, value: F::LeafValue)

Reads a token. Creates a leaf bocage node with the given value. After reading one or more tokens, the parse can be advanced.

pub fn lookahead_hint(&mut self, lookahead: Option<Symbol>)

pub fn end_earleme(&mut self) -> bool

Advances the parse. Calling this method may set the finished node, which can be accessed through the finished_node method.

pub fn advance_without_completion(&mut self)

Advances the parse. Omits the completion pass, which should be done through the completions method. Keep in mind that calling this method may not set the finished node, which should be tracked externally.

pub fn is_exhausted(&self) -> bool

Checks whether the recognizer is exhausted. The recognizer is exhausted when it can’t accept more input.

pub fn complete(&mut self, set_id: Origin, sym: Symbol, rhs_link: F::NodeRef)

Complete items.

pub fn reset(&mut self)

Resets the recognizer to its initial state by removing all contents.

pub fn is_finished(&self) -> bool

Checks whether there is a valid parse that ends at the current position.

pub fn finished_node(&self) -> Option<F::NodeRef>

Retrieves the bocage node that represents the parse that has finished at the current location.

Panics

Panics when the parse has not finished at the current location.

pub fn predicted_symbols(&self) -> PredictedSymbols<'_>

Accesses predicted symbols.

pub fn medial_items(&self) -> MedialItems<'_, F::NodeRef>

Accesses medial items.

pub fn earleme(&self) -> usize

Returns the current location number.

pub fn complete_all_sums_entirely(&mut self)

Performs the completion pass.

pub fn next_sum<'r>(&'r mut self) -> Option<CompleteSum<'g, 'r, F>>

Allows iteration through groups of completions that have unique symbol and origin.

impl<'g, F> Recognizer<'g, F>

where F: Forest,

pub fn heap_peek(&self) -> Option<CompletedItem<F::NodeRef>>

Returns the greatest item in the binary heap, or None if it is empty.

pub fn heap_pop(&mut self) -> Option<CompletedItem<F::NodeRef>>

Removes the greatest item from the binary heap and returns it, or None if it is empty.

pub fn heap_push(&mut self, item: CompletedItem<F::NodeRef>)

Pushes an item onto the binary heap.

pub fn heap_push_linked(&mut self, item: CompletedItemLinked<F::NodeRef>)

Pushes an item onto the binary heap.

Trait Implementations

impl<'g, F: Forest> Debug for Recognizer<'g, F>

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

Formats the value using the given formatter.

impl<'g, F> MemoryUse for Recognizer<'g, F>

where F: MemoryUse<Arg = &'g InternalGrammar> + Forest,

type Arg = &'g InternalGrammar

fn memory_use(&self) -> usize

fn new_with_limit(grammar: &'g InternalGrammar, memory_limit: usize) -> Self

impl<'g> MemoryUse for Recognizer<'g, NullForest>

type Arg = &'g InternalGrammar

fn memory_use(&self) -> usize

fn new_with_limit(grammar: &'g InternalGrammar, memory_limit: usize) -> Self