Struct antlr_rust::BailErrorStrategy

pub struct BailErrorStrategy<'input, Ctx: ParserNodeType<'input>>(_);

This implementation of ANTLRErrorStrategy responds to syntax errors by immediately canceling the parse operation with a ParseCancellationException. The implementation ensures that the ParserRuleContext.exception field is set for all parse tree nodes that were not completed prior to encountering the error.

This error strategy is useful in the following scenarios.

• Two-stage parsing: This error strategy allows the first stage of two-stage parsing to immediately terminate if an error is encountered, and immediately fall back to the second stage. In addition to avoiding wasted work by attempting to recover from errors here, the empty implementation of sync improves the performance of the first stage.
• Silent validation: When syntax errors are not being reported or logged, and the parse result is simply ignored if errors occur, the BailErrorStrategy avoids wasting work on recovering from errors when the result will be ignored either way.

Usage

use antlr_rust::error_strategy::BailErrorStrategy;
myparser.err_handler = BailErrorStrategy::new();

*/

Implementations

impl<'input, Ctx: ParserNodeType<'input>> BailErrorStrategy<'input, Ctx>

pub fn new() -> Self

Creates new instance of BailErrorStrategy

Trait Implementations

impl<'input, Ctx: Debug + ParserNodeType<'input>> Debug for BailErrorStrategy<'input, Ctx>

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

Formats the value using the given formatter.

impl<'input, Ctx: Default + ParserNodeType<'input>> Default for BailErrorStrategy<'input, Ctx>

fn default() -> BailErrorStrategy<'input, Ctx>

Returns the “default value” for a type.

impl<'a, T: Parser<'a>> ErrorStrategy<'a, T> for BailErrorStrategy<'a, T::Node>

fn reset(&mut self, recognizer: &mut T)

Reset the error handler state for the specified recognizer.

fn recover_inline(
    &mut self,
    recognizer: &mut T
) -> Result<<T::TF as TokenFactory<'a>>::Tok, ANTLRError>

This method is called when an unexpected symbol is encountered during an inline match operation, such as Parser::match. If the error strategy successfully recovers from the match failure, this method returns the Token instance which should be treated as the successful result of the match.

fn recover(
    &mut self,
    recognizer: &mut T,
    e: &ANTLRError
) -> Result<(), ANTLRError>

This method is called to recover from error e. This method is called after ErrorStrategy::reportError by the default error handler generated for a rule method.

fn sync(&mut self, _recognizer: &mut T) -> Result<(), ANTLRError>

This method provides the error handler with an opportunity to handle syntactic or semantic errors in the input stream before they result in a error.

fn in_error_recovery_mode(&mut self, recognizer: &mut T) -> bool

Tests whether or not {@code recognizer} is in the process of recovering from an error. In error recovery mode, Parser::consume will create ErrorNode leaf instead of TerminalNode one

fn report_error(&mut self, recognizer: &mut T, e: &ANTLRError)

Report any kind of ANTLRError. This method is called by the default exception handler generated for a rule method.

fn report_match(&mut self, _recognizer: &mut T)

This method is called when the parser successfully matches an input symbol.

impl<'i, Ctx: TidAble<'i>> TidAble<'i> for BailErrorStrategy<'i, Ctx> where
    Ctx: ParserNodeType<'i>,