Struct Parser 

pub struct Parser {
    pub resolve_modules: bool,
    pub tokens: Vec<Token>,
    pub token_index: usize,
    pub current_module: String,
    pub previous: Option<Token>,
}

Fields

resolve_modules: bool

tokens: Vec<Token>

token_index: usize

current_module: String

previous: Option<Token>

Implementations

impl Parser

pub fn new() -> Self

pub fn set_current_module(&mut self, module_path: String)

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

pub fn peek_is(&self, expected: &str) -> bool

pub fn peek_nth(&self, n: usize) -> Option<&Token>

pub fn peek_nth_kind(&self, n: usize) -> Option<TokenKind>

pub fn advance_if(&mut self, kind: TokenKind) -> bool

pub fn match_token(&mut self, kind: TokenKind) -> bool

pub fn previous_clone(&self) -> Option<Token>

pub fn parse_block( &self, tokens: Vec<Token>, global_store: &mut GlobalStore, ) -> Vec<Statement>

pub fn parse_tokens( &mut self, tokens: Vec<Token>, global_store: &mut GlobalStore, ) -> Vec<Statement>

pub fn check_token(&self, kind: TokenKind) -> bool

pub fn peek_kind(&self) -> Option<TokenKind>

pub fn parse_map_value(&mut self) -> Option<Value>

pub fn parse_array_value(&mut self) -> Option<Value>

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

pub fn peek_clone(&self) -> Option<Token>

pub fn expect(&mut self, kind: TokenKind) -> Result<&Token, String>

pub fn collect_block_tokens(&mut self, base_indent: usize) -> Vec<Token>

pub fn collect_until<F>(&mut self, condition: F) -> Vec<Token>

where F: Fn(&Token) -> bool,

pub fn is_eof(&self) -> bool

pub fn parse_block_until_next_else( &mut self, base_indent: usize, global_store: &mut GlobalStore, ) -> Vec<Statement>

pub fn parse_condition_until_colon(&mut self) -> Option<Value>

pub fn parse_block_until_else_or_dedent( &mut self, base_indent: usize, global_store: &mut GlobalStore, ) -> Vec<Statement>

Trait Implementations

impl Clone for Parser

fn clone(&self) -> Parser

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Parser

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

Formats the value using the given formatter.

impl PartialEq for Parser

fn eq(&self, other: &Parser) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Parser