Struct GssHead 

pub struct GssHead<'i, I, S, TK>
where
    I: Input + ?Sized,
{
    pub frontier: usize,
    /* private fields */
}

A node/head in the Graph Structured Stack (GSS). Implements Context for GLR parsing.

Each head is related to a LR parser state and a single token ahead. Lexical ambiguity, where a head may be followed by multiple different tokens, is handled by splitting the head and using the same GLR mechanics for syntax ambiguity handling. Effectively, we have per-token sub-frontiers.

Fields

frontier: usize

A frontier this node belongs to

Implementations

impl<'i, I, S, TK> GssHead<'i, I, S, TK>

where I: Input + ?Sized, S: State, TK: Copy,

pub fn new( state: S, frontier: usize, position: usize, range: Range<usize>, location: Location, layout_ahead: Option<&'i I>, token_ahead: Option<Token<'i, I, TK>>, ) -> Self

pub fn with_tok_state(&self, token_ahead: Token<'i, I, TK>, state: S) -> Self

pub fn with_tok(&self, token_ahead: Token<'i, I, TK>) -> Self

Trait Implementations

impl<I, S, TK> Clone for GssHead<'_, I, S, TK>

where I: Input + ?Sized, S: State, TK: Copy,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'i, S, I, TK> Context<'i, I, S, TK> for GssHead<'i, I, S, TK>

where I: Input + ?Sized, S: State,

fn state(&self) -> S

The current parser state.

fn set_state(&mut self, state: S)

fn position(&self) -> usize

An absolute position in the input sequence

fn set_position(&mut self, position: usize)

fn location(&self) -> Location

A span in the input sequence, possibly in line-column style.

fn set_location(&mut self, location: Location)

fn range(&self) -> Range<usize>

A span in the input sequence

fn set_range(&mut self, range: Range<usize>)

fn token_ahead(&self) -> Option<&Token<'i, I, TK>>

Next token recognized in the input at the current parsing location

fn set_token_ahead(&mut self, token: Token<'i, I, TK>)

fn layout_ahead(&self) -> Option<&'i I>

A layout before the token ahead

fn set_layout_ahead(&mut self, layout: Option<&'i I>)

impl<'i, I, S: Debug, TK: Debug> Debug for GssHead<'i, I, S, TK>

where I: Input + ?Sized + Debug,

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

Formats the value using the given formatter.

impl<I: Input + ?Sized, S: Default, TK> Default for GssHead<'_, I, S, TK>

fn default() -> Self

Returns the “default value” for a type.

impl<'i, I, S, TK, NTK, L, P, D, B> Parser<'i, I, GssHead<'i, I, S, TK>, S, TK> for GlrParser<'i, S, L, P, TK, NTK, D, I, B>

where I: Input + ?Sized + Debug, L: Lexer<'i, GssHead<'i, I, S, TK>, S, TK, Input = I>, S: State + Debug + Ord, P: Copy + Debug + Into<NTK> + PartialEq, TK: Copy + Debug + Ord + Default + 'i, D: ParserDefinition<S, P, TK, NTK>,

type Output = Forest<'i, I, P, TK>

fn parse(&self, input: &'i I) -> Result<Self::Output>

Parse the given input and produce the result. The output type is set by the parser implementers and it is usually defined by the builder if the building is done during the parse process.

fn parse_with_context( &self, context: &mut GssHead<'i, I, S, TK>, input: &'i I, ) -> Result<Self::Output>

Parse with the given context which has information about the current parsing state (e.g. position, location). Used in situation when we need to continue parsing from a specific state, like in parsing the layout from the current location.

fn parse_file<'a, F: AsRef<Path>>(&'a mut self, file: F) -> Result<Self::Output>

where 'a: 'i,

A convenience method for loading the content from the given file and calling parse. The parser will own the content being parsed and thus has to outlive Self::Output if it borrows from the content loaded from the file.