Struct lalr::Grammar

pub struct Grammar<T, N, A> {
    pub rules: BTreeMap<N, Vec<Rhs<T, N, A>>>,
    pub start: N,
}

A context-free grammar.

Fields

rules: BTreeMap<N, Vec<Rhs<T, N, A>>>

The rules for each nonterminal.

start: N

The starting state. There must be exactly one rule of the form "start -> N", for some nonterminal N. start must not be referred to elsewhere in the grammar.

Methods

impl<T: Ord, N: Ord, A> Grammar<T, N, A>

fn lr0_state_machine<'a>(&'a self) -> LR0StateMachine<'a, T, N, A>

Create the LR(0) state machine for a grammar.

fn first_sets(&self) -> BTreeMap<&N, (BTreeSet<&T>, bool)>

Compute the FIRST sets of the grammar. Returns a map from nonterminal to (first set, nullable).

fn follow_sets<'a>(
    &'a self,
    first: BTreeMap<&'a N, (BTreeSet<&'a T>, bool)>
) -> BTreeMap<&'a N, (BTreeSet<&'a T>, bool)>

Compute the FOLLOW sets of the grammar. Returns a map mapping from nonterminal to (follow set, whether follow set contains EOF)

fn lalr1<'a, FR, FO>(
    &'a self,
    reduce_on: FR,
    priority_of: FO
) -> Result<LR1ParseTable<'a, T, N, A>, LR1Conflict<'a, T, N, A>> where
    FR: FnMut(&Rhs<T, N, A>, Option<&T>) -> bool,
    FO: FnMut(&Rhs<T, N, A>, Option<&T>) -> i32, 

Try to create an LALR(1) parse table out of the grammar.

You can tweak the behaviour of the parser in two ways:

• reduce_on is a predicate, allowing you to control certain reduce rules based on the lookahead token. This function takes two parameters: the rule, given by its right-hand side, and the lookahead token (or None for EOF). You can use this to resolve shift-reduce conflicts. For example, you can solve the "dangling else" problem by forbidding the reduce action on an else token.
• priority_of allows you to resolve reduce-reduce conflicts, by giving reduce rules different "priorities". This takes the same parameters as reduce_on, so you can vary the priority based on the lookahead token. If there would be a reduce-reduce conflict between rules, but they have different priority, the one with higher priority is used.

Trait Implementations

impl<T: Debug, N: Debug, A: Debug> Debug for Grammar<T, N, A>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.