Struct Parser 

pub struct Parser<'a> {
    pub mode: Mode,
    pub gullet: MacroExpander<'a>,
    pub leftright_depth: i32,
    pub equation_counter: usize,
    /* private fields */
}

Maximum supported nesting for input-controlled recursive structures.

Keep this conservative: parsing is used from mobile and WebAssembly hosts whose worker stacks can be substantially smaller than a desktop main-thread stack. The LaTeX parser. Converts a token stream into a ParseNode AST.

Follows KaTeX’s Parser.ts closely:

• parse() → parse full expression
• parseExpression() → parse a list of atoms
• parseAtom() → parse one atom with optional super/subscripts
• parseGroup() → parse a group (braced or single token)
• parseFunction() → parse a function call with arguments
• parseSymbol() → parse a single symbol

Fields

mode: Mode

gullet: MacroExpander<'a>

leftright_depth: i32

equation_counter: usize

Implementations

impl<'a> Parser<'a>

pub fn new(input: &'a str) -> Self

pub fn fetch(&mut self) -> ParseResult<Token>

Return the current lookahead token (fetching from gullet if needed).

pub fn consume(&mut self)

Discard the current lookahead token.

pub fn expect(&mut self, text: &str, do_consume: bool) -> ParseResult<()>

Expect the next token to have the given text, consuming it.

pub fn consume_spaces(&mut self) -> ParseResult<()>

Consume spaces in math mode.

pub fn switch_mode(&mut self, new_mode: Mode)

Switch between “math” and “text” modes.

pub fn parse(&mut self) -> ParseResult<Vec<ParseNode>>

Parse the entire input and return the AST.

pub fn parse_expression( &mut self, break_on_infix: bool, break_on_token_text: Option<&str>, ) -> ParseResult<Vec<ParseNode>>

Parse an expression: a list of atoms.

pub fn parse_atom( &mut self, break_on_token_text: Option<&str>, ) -> ParseResult<Option<ParseNode>>

Parse a single atom with optional super/subscripts.

pub fn parse_group( &mut self, name: &str, break_on_token_text: Option<&str>, ) -> ParseResult<Option<ParseNode>>

Parse a group: braced expression, function call, or single symbol.

pub fn parse_function( &mut self, break_on_token_text: Option<&str>, name: Option<&str>, ) -> ParseResult<Option<ParseNode>>

Try to parse a function call. Returns None if not a function.

pub fn call_function( &mut self, name: &str, args: Vec<ParseNode>, opt_args: Vec<Option<ParseNode>>, token: Option<Token>, break_on_token_text: Option<&str>, ) -> ParseResult<ParseNode>

Call a function handler.

pub fn parse_arguments( &mut self, func: &str, func_data: &FunctionSpec, ) -> ParseResult<(Vec<ParseNode>, Vec<Option<ParseNode>>)>

Parse the arguments for a function.

pub fn parse_size_group( &mut self, optional: bool, ) -> ParseResult<Option<ParseNode>>

Parse a size group (e.g., “3pt”, “1em”).

pub fn parse_argument_group( &mut self, optional: bool, mode: Option<Mode>, ) -> ParseResult<Option<ParseNode>>

Parse an argument group (with optional mode switch).

pub fn subparse(&mut self, tokens: Vec<Token>) -> ParseResult<Vec<ParseNode>>

Parse a sub-expression from the given tokens.