Struct __StateMachine

struct __StateMachine<'memory, '__1, '__2>
where
    'memory: '__2,
{
    inputs: &'__1 [Token],
    memory: &'__2 mut CombinedMemory<'memory>,
    __phantom: PhantomData<&'memory ()>,
}

Fields

inputs: &'__1 [Token]

memory: &'__2 mut CombinedMemory<'memory>

__phantom: PhantomData<&'memory ()>

Trait Implementations

impl<'memory, '__1, '__2> ParserDefinition for __StateMachine<'memory, '__1, '__2>

where 'memory: '__2,

type Location = usize

Represents a location in the input text. If you are using the default tokenizer, this will be a usize.

type Error = LexError

Represents a “user error” – this can get produced by reduce() if the grammar includes =>? actions.

type Token = Lexeme

The type emitted by the user’s tokenizer (excluding the location information).

type TokenIndex = usize

We assign a unique index to each token in the grammar, which we call its index. When we pull in a new Token from the input, we then match against it to determine its index. Note that the actual Token is retained too, as it may carry additional information (e.g., an ID terminal often has a string value associated with it; this is not important to the parser, but the semantic analyzer will want it).

type Symbol = __Symbol

The type representing things on the LALRPOP stack. Represents the union of terminals and nonterminals.

type Success = Block

Type produced by reducing the start symbol.

type StateIndex = i8

Identifies a state. Typically an i8, i16, or i32 (depending on how many states you have).

type Action = i8

Identifies an action.

type ReduceIndex = i8

Identifies a reduction.

type NonterminalIndex = usize

Identifies a nonterminal.

fn start_location(&self) -> Self::Location

Returns a location representing the “start of the input”.

fn start_state(&self) -> Self::StateIndex

Returns the initial state.

fn token_to_index(&self, token: &Self::Token) -> Option<usize>

Converts the user’s tokens into an internal index; this index is then used to index into actions and the like. When using an internal tokenizer, these indices are directly produced. When using an external tokenier, however, this function matches against the patterns given by the user: it is fallible therefore as these patterns may not be exhaustive. If a token value is found that doesn’t match any of the patterns the user supplied, then this function returns None, which is translated into a parse error by LALRPOP (“unrecognized token”).

fn action(&self, state: i8, integer: usize) -> i8

Given the top-most state and the pending terminal, returns an action. This can be either SHIFT(state), REDUCE(action), or ERROR.

fn error_action(&self, state: i8) -> i8

Returns the action to take if an error occurs in the given state. This function is the same as the ordinary action, except that it applies not to the user’s terminals but to the “special terminal” !.

fn eof_action(&self, state: i8) -> i8

Action to take if EOF occurs in the given state. This function is the same as the ordinary action, except that it applies not to the user’s terminals but to the “special terminal” $.

fn goto(&self, state: i8, nt: usize) -> i8

If we reduce to a nonterminal in the given state, what state do we go to? This is infallible due to the nature of LR(1) grammars.

fn token_to_symbol( &self, token_index: usize, token: Self::Token, ) -> Self::Symbol

“Upcast” a terminal into a symbol so we can push it onto the parser stack.

fn expected_tokens(&self, state: i8) -> Vec<String>

Returns the expected tokens in a given state. This is used for error reporting.

fn expected_tokens_from_states(&self, states: &[i8]) -> Vec<String>

Returns the expected tokens in a given state. This is used in the same way as expected_tokens but allows more precise reporting of accepted tokens in some cases.

fn uses_error_recovery(&self) -> bool

True if this grammar supports error recovery.

fn error_recovery_symbol(&self, recovery: ErrorRecovery<Self>) -> Self::Symbol

Given error information, creates an error recovery symbol that we push onto the stack (and supply to user actions).

fn reduce( &mut self, action: i8, start_location: Option<&Self::Location>, states: &mut Vec<i8>, symbols: &mut Vec<SymbolTriple<Self>>, ) -> Option<ParseResult<Self>>

Execute a reduction in the given state: that is, execute user code. The start location indicates the “starting point” of the current lookahead that is triggering the reduction (it is None for EOF).

fn simulate_reduce(&self, action: i8) -> SimulatedReduce<Self>

Returns information about how many states will be popped during a reduction, and what nonterminal would be produced as a result.