Struct Parser

pub struct Parser { /* private fields */ }

Available on crate feature parser only.

The Parser struct wraps a Lexer and adds lookahead and functions that are useful for parsing.

Implementations

impl Parser

pub fn new(lexer: Lexer) -> Self

Construct a new parser around a given Lexer.

pub fn lexer(&self) -> &Lexer

Get the Lexer that’s wrapped.

pub fn lookahead(&mut self, k: usize) -> Option<&Token>

Lookahead k Tokens.

If k == 0 then this is effectively peeking at the next Token from the wrapped Lexer.

pub fn peek(&mut self) -> Option<&Token>

Peek at the next token from the Lexer (cached in the lookahead queue if peeked before).

pub fn peek_fragment(&mut self) -> Option<&Fragment>

Peek the Fragment of the next Token.

pub fn peek_variant(&mut self) -> Option<TokenTy>

Peek the TokenTy of the next Token.

pub fn lookahead_window(&mut self, n: usize) -> Option<&[Token]>

Similar to Parser::lookahead but instead returns a slice of n Tokens, starting with the next Token.

Returns None if n is greater than the number of remaining Tokens for this Parser.

pub fn peek_next_not_whitespace(&mut self) -> Option<&Token>

Peek the next token that’s not whitespace.

pub fn bytes_remaining(&self) -> usize

Get the number of remaining bytes on this parser. This is potentially useful for checking if a parser has advanced between two calls (or checking if a parser has reached end of input).

pub fn next_token(&mut self) -> Result<Option<Token>, ParserError>

Get the next Token from this Parser. This may be a token that’s already been peeked.

Skips any non-document comments encountered via the lexer implementation.

Return an error if a Token with TokenTy::Unknown is encountered.

pub fn advance(&mut self, n: usize)

Advance this Parser by n Tokens. If this Parser runs out of Tokens, panic.

Panics

• If n is greater than the number of remaining tokens.

pub fn peek_fragment_or_rest_cloned(&mut self) -> Fragment

Peek the Fragment of the next Token and clone it or return a clone of the remainder Fragment of the internal Lexer (which will be empty, since there wasn’t a Token to peek).

This is likely only useful for error reporting – a clone of a potentially empty fragment is rarely ever useful otherwise.

pub fn next_if_is(&mut self, token_ty: TokenTy) -> Option<Token>

Get the next Token from this parser if its Token::variant is the given token_ty.

pub fn matches(&mut self, seq: &[TokenTy]) -> bool

Peek at the next Tokens of this Parser and determine if the Token::variants match this sequence of TokenTys.

pub fn consume_optional_whitespace(&mut self)

Consume & remove all whitespace tokens from the front of the parser.

pub fn consume_at_least_one_whitespace(&mut self) -> Result<(), ParserError>

Require a whitespace from the Parser. Do not advance if the next Token is not a whitespace.

Trait Implementations

impl Debug for Parser

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

Formats the value using the given formatter.