Struct ParserMachine

pub struct ParserMachine<I: ParserInput, S: StateSpace> { /* private fields */ }

A parser state machine.

This struct implements the parse stack and driver for the parser. It is generic over the means by which terminals arrive at the input.

Implementations

impl<I: ParserInput<Item = S::Terminal>, S: StateSpace> ParserMachine<I, S>

pub fn new(input: I) -> ParserMachine<I, S>

Create a new parser state machine.

pub fn run(self) -> S::Nonterminal

Run the parser to completion.

impl<I: Iterator, S: StateSpace<Terminal = Option<I::Item>>> ParserMachine<IterInput<I>, S>

pub fn from_iter(input: I) -> ParserMachine<IterInput<I>, S>

Create a new parser state machine from an iterator.

Trait Implementations

impl<I, S> Parser for ParserMachine<I, S>

where I: ParserInput<Item = S::Terminal>, S: StateSpace,

type Terminal = <S as StateSpace>::Terminal

The type of terminals the parser emits.

type Nonterminal = <S as StateSpace>::Nonterminal

The type of nonterminals the parser emits. This is likely an enum over all nonterminals generated automatically.

fn peek(&mut self) -> &S::Terminal

Peek at the next terminal in the sequence without shifting it.

fn shift( &mut self, state_fn: fn(_: &mut Self), goto_fn: fn(_: &mut Self, _: S::Nonterminal), )

Push the next terminal onto the stack.

fn goto( &mut self, nonterminal: S::Nonterminal, state_fn: fn(_: &mut Self), goto_fn: fn(_: &mut Self, _: S::Nonterminal), )

Push a nonterminal onto the stack.

fn reduce<F: Fn(Vec<Symbol<S::Terminal, S::Nonterminal>>) -> S::Nonterminal>( &mut self, length: usize, f: F, )

Reduce the tail of the stack to a nonterminal.

fn accept(&mut self)

Accept the last symbol on the stack as the parse result.