Struct TermLexerDriver 

pub struct TermLexerDriver<I> {
    pub buffer2: Vec<u8>,
    pub span2: Span,
    /* private fields */
}

Stateful driver that handles rule matches from the generated DFA.

TermLexerDriver receives callbacks when a rule matches. It can:

• emit tokens (e.g., identifiers, numbers, operators),
• adjust internal bookkeeping (e.g., nested comment depth),
• switch modes (e.g., on comment boundaries).

The driver is parameterized by an input type I that yields bytes and supports contextual access to Arena.

Internal State

• comment_level: current nesting depth of block comments; positive values mean we’re inside a comment.
• _marker: binds the generic I without storage.

Associated Types (via LexerDriver)

• LexerData = LexData
• Token = TermToken
• Lexer = Lexer<I, Self, Arena>
• Error = TermError
• Context = Arena

Errors

• TermError::ParseInt for invalid numeric literals,
• TermError::FromUtf8 for invalid UTF-8 when decoding identifiers,

Fields

buffer2: Vec<u8>

Secondary buffer.

span2: Span

Secondary span.

Trait Implementations

impl<I> LexerDriver for TermLexerDriver<I>

where I: TryNextWithContext<Arena, Item = u8, Error: Display + 'static>,

type LexerData = LexData

Rule identifiers and metadata produced by the lexer generator.

type Token = TermToken

Concrete token type emitted by the driver.

type Lexer = Lexer<I, TermLexerDriver<I>, <TermLexerDriver<I> as LexerDriver>::Context>

Concrete lexer type parameterized by input, driver and context.

type Context = Arena

Externally supplied context available to actions (symbol table).

fn action( &mut self, lexer: &mut Self::Lexer, arena: &mut Self::Context, rule: <Self::LexerData as LexerData>::LexerRule, ) -> Result<(), ParlexError>

Handles a single lexer rule match.

Called by the lexer when a DFA rule in Lexer fires. The implementation typically inspects rule, reads the matched span from lexer, and either:

• emits a TermToken (e.g., numbers, operators),
• updates internal state (e.g., comment_nest_count),
• or returns an error if the match is invalid.

Implementations may also use context (an Arena) to intern identifiers and store terms in Value::Term.

Errors

Propagates any lexical, parsing, UTF-8 decoding, or arena errors as [TermError].