use std::collections::HashMap;
use dbt_antlr_runtime::atn::{ATN, INVALID_ALT};
use dbt_antlr_runtime::atn_simulator::ParserATNSimulatorManager;
use dbt_antlr_runtime::atn_state::{ATNState, ATNStateType, RuleStartState, StarLoopEntryState};
use dbt_antlr_runtime::common_token_stream::CommonTokenStream;
use dbt_antlr_runtime::dfa::static_parser_dfa::StaticParserTables as RuntimeTables;
use dbt_antlr_runtime::error_strategy::ErrorStrategy;
use dbt_antlr_runtime::errors::{ANTLRError, ANTLRErrorKind};
use dbt_antlr_runtime::interpreter_rule_context::{
InterpreterNode, InterpreterNodeKind, InterpreterRuleContextExt,
};
use dbt_antlr_runtime::parser::{BaseParser, Parser, ParserRecog};
use dbt_antlr_runtime::parser_rule_context::{BaseParserRuleContext, ParserRuleContext};
use dbt_antlr_runtime::recognizer::Actions;
use dbt_antlr_runtime::rule_context::RuleContext;
use dbt_antlr_runtime::token::{TOKEN_EOF, TOKEN_MIN_USER_TOKEN_TYPE, Token};
use dbt_antlr_runtime::token_factory::CommonTokenFactory;
use dbt_antlr_runtime::transition::{
PrecedencePredicateTransition, RuleTransition, TransitionType,
};
use dbt_antlr_runtime::tree::Tree;
use dbt_antlr_runtime::vocabulary::Vocabulary;
use dbt_antlr_runtime::{Arena, PredictionMode};
use super::lex::{ExplainLexer, LexerSpec};
use crate::grammar::atn::DecisionLookahead;
use crate::optimization::parser_dfa::{DecisionOutcome, EscapeResolution, StaticDfaTable};
use crate::optimization::{DescentGroup, StaticParserTables};
type ExplainTokens<'input, 'arena> = CommonTokenStream<
'input,
'arena,
ExplainLexer<'input, 'arena>,
CommonTokenFactory<'input, 'arena>,
>;
type ExplainBase<'input, 'arena> = BaseParser<
'input,
'arena,
ExplainParserExt,
InterpreterNodeKind,
ExplainTokens<'input, 'arena>,
CommonTokenFactory<'input, 'arena>,
>;
type ExplainNode<'input, 'arena> =
InterpreterNode<'input, 'arena, dbt_antlr_runtime::token::CommonToken<'input>>;
pub(super) struct ExplainParserExt {
grammar_file_name: &'static str,
rule_names: &'static [&'static str],
vocabulary: Box<dyn Vocabulary>,
atn_manager: &'static ParserATNSimulatorManager,
}
impl<'input, 'arena> Actions<'input, 'arena, ExplainBase<'input, 'arena>, ExplainTok<'input>>
for ExplainParserExt
{
fn get_grammar_file_name(&self) -> &str {
self.grammar_file_name
}
fn get_rule_names(&self) -> &[&str] {
self.rule_names
}
fn get_vocabulary(&self) -> &dyn Vocabulary {
&*self.vocabulary
}
}
impl<'input, 'arena> ParserRecog<'input, 'arena, ExplainBase<'input, 'arena>, ExplainTok<'input>>
for ExplainParserExt
{
fn get_atn_simulator_man(&self) -> &'static ParserATNSimulatorManager {
self.atn_manager
}
}
type ExplainTok<'input> = dbt_antlr_runtime::token::CommonToken<'input>;
struct FailFast;
impl<'input, 'arena>
ErrorStrategy<'input, 'arena, CommonTokenFactory<'input, 'arena>, ExplainBase<'input, 'arena>>
for FailFast
{
fn reset(&mut self, _recognizer: &mut ExplainBase<'input, 'arena>) {}
fn recover_inline(
&mut self,
recognizer: &mut ExplainBase<'input, 'arena>,
) -> Result<&'arena ExplainTok<'input>, ANTLRError> {
Err(ANTLRError::input_mismatch(recognizer))
}
fn recover(
&mut self,
_recognizer: &mut ExplainBase<'input, 'arena>,
e: &ANTLRError,
) -> Result<(), ANTLRError> {
Err(e.clone())
}
fn sync(&mut self, _recognizer: &mut ExplainBase<'input, 'arena>) -> Result<(), ANTLRError> {
Ok(())
}
fn in_error_recovery_mode(&mut self, _recognizer: &mut ExplainBase<'input, 'arena>) -> bool {
false
}
fn report_error(&mut self, _recognizer: &mut ExplainBase<'input, 'arena>, _e: &ANTLRError) {}
fn report_match(&mut self, _recognizer: &mut ExplainBase<'input, 'arena>) {}
}
pub(super) struct StaticOracle<'r> {
pub(super) results: &'r [DecisionOutcome],
pub(super) tables: &'r StaticParserTables,
pub(super) runtime: &'static RuntimeTables,
pub(super) ll1: HashMap<usize, &'r DecisionLookahead>,
pub(super) static_only: bool,
}
pub(super) enum Oracle<'r> {
Static(StaticOracle<'r>),
FullLl {
probe: Option<usize>,
},
}
pub(super) struct ParserSpec {
pub(super) grammar_file_name: &'static str,
pub(super) rule_names: &'static [&'static str],
pub(super) literal_names: Vec<Option<String>>,
pub(super) symbolic_names: Vec<Option<String>>,
pub(super) atn: &'static ATN,
}
impl ParserSpec {
fn vocabulary(&self) -> Box<dyn Vocabulary> {
Box::new(dbt_antlr_runtime::vocabulary::VocabularyImpl::new(
self.literal_names.iter(),
self.symbolic_names.iter(),
None,
))
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) struct Frame {
pub(super) rule: usize,
pub(super) start: isize,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum TableKind {
Exact,
Fallback,
MinAlt,
MinViableAlt,
GuardTaken,
GuardDeferred,
SyntaxError,
Escape,
Unknown,
}
impl TableKind {
pub(super) const fn is_guess(self) -> bool {
matches!(
self,
Self::MinAlt | Self::MinViableAlt | Self::GuardDeferred
)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) struct TableWalk {
pub(super) class: Option<usize>,
pub(super) state: usize,
pub(super) lookahead: Vec<isize>,
pub(super) kind: TableKind,
pub(super) dropped: Vec<i32>,
expected: Option<i32>,
guard: Option<(i32, i32)>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) enum Resolution {
Pending,
Ll1 { matched: bool },
Table(TableWalk),
Descent {
group: i32,
rule: usize,
tail: isize,
walk: Option<TableWalk>,
alts: Vec<i32>,
neutral_end: usize,
},
DescentFallback { group: i32 },
DescentAborted {
group: i32,
alts: Vec<i32>,
walk: Option<TableWalk>,
},
NoStaticTable,
Adaptive,
FullLl,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) struct DecisionEvent {
pub(super) decision: usize,
pub(super) rule: usize,
pub(super) token_index: isize,
pub(super) stack: Vec<Frame>,
pub(super) alt: Option<i32>,
pub(super) resolution: Resolution,
}
impl DecisionEvent {
pub(super) fn is_guess(&self) -> bool {
match &self.resolution {
Resolution::Table(walk) => walk.kind.is_guess(),
Resolution::Descent {
walk: Some(walk), ..
} => walk.kind.is_guess(),
Resolution::DescentFallback { .. } => true,
_ => false,
}
}
pub(super) fn walk(&self) -> Option<&TableWalk> {
match &self.resolution {
Resolution::Table(walk)
| Resolution::Descent {
walk: Some(walk), ..
}
| Resolution::DescentAborted {
walk: Some(walk), ..
} => Some(walk),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum ErrorKind {
NoViableAlt,
Mismatch,
FailedPredicate,
Other,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) struct SyntaxError {
pub(super) kind: ErrorKind,
pub(super) token_index: isize,
pub(super) expected: Vec<i32>,
pub(super) stack: Vec<Frame>,
pub(super) step: Option<usize>,
pub(super) message: String,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) enum Outcome {
Accepted {
stop: isize,
},
Failed(SyntaxError),
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) struct Trace {
pub(super) events: Vec<DecisionEvent>,
pub(super) outcome: Outcome,
pub(super) probe: Option<Option<i32>>,
}
pub(super) fn simulate(
spec: &ParserSpec,
lexer: &LexerSpec,
input: &str,
oracle: &Oracle<'_>,
start_rule: usize,
) -> Trace {
let atn_manager: &'static ParserATNSimulatorManager = match oracle {
Oracle::Static(static_oracle) => Box::leak(Box::new(
ParserATNSimulatorManager::new_with_static_parser_tables(
spec.atn,
static_oracle.runtime,
),
)),
Oracle::FullLl { .. } => Box::leak(Box::new(ParserATNSimulatorManager::new(spec.atn))),
};
Arena::with(|arena| {
let tokens = CommonTokenStream::new(lexer.lexer(arena, input));
let mut base = BaseParser::new_base_parser(
arena,
tokens,
ExplainParserExt {
grammar_file_name: spec.grammar_file_name,
rule_names: spec.rule_names,
vocabulary: spec.vocabulary(),
atn_manager,
},
);
base.remove_error_listeners();
base.get_interpreter()
.set_prediction_mode(PredictionMode::LL);
let mut simulation = Simulation {
base,
atn: spec.atn,
oracle,
parent_context_stack: Vec::new(),
depth: 0,
events: Vec::new(),
probe: None,
call_sites: HashMap::new(),
};
let outcome = match simulation.parse(start_rule) {
Ok(()) => Outcome::Accepted {
stop: simulation.base.get_input_stream().index(),
},
Err(error) => Outcome::Failed(simulation.syntax_error(&error)),
};
Trace {
events: simulation.events,
outcome,
probe: simulation.probe,
}
})
}
const PROBE_DONE: &str = "explain: probe done";
struct Simulation<'input, 'arena, 'o, 'r> {
base: ExplainBase<'input, 'arena>,
atn: &'static ATN,
oracle: &'o Oracle<'r>,
parent_context_stack: Vec<(Option<&'arena ExplainNode<'input, 'arena>>, i32)>,
depth: usize,
events: Vec<DecisionEvent>,
probe: Option<Option<i32>>,
call_sites: HashMap<(usize, i32), &'static [i32]>,
}
impl<'input, 'arena> Simulation<'input, 'arena, '_, '_> {
fn parse(&mut self, start_rule: usize) -> Result<(), ANTLRError> {
let start_state = self.atn.rule_to_start_state[start_rule];
let left_recursive = is_left_recursive_rule(start_state.as_ref());
let root = self.create_context(None, -1, start_rule)?;
if left_recursive {
self.enter_recursion_rule(root, start_state.get_state_number(), start_rule, 0)?;
} else {
self.base
.enter_rule(root, start_state.get_state_number(), start_rule)?;
}
self.depth = 1;
self.run_until(1)?;
if left_recursive {
let (parent, _) = self
.parent_context_stack
.pop()
.expect("left-recursive start rule has a parent context");
self.base.unroll_recursion_context(parent)?;
} else {
self.base.exit_rule()?;
}
Ok(())
}
fn run_until(&mut self, depth: usize) -> Result<(), ANTLRError> {
loop {
let state = self.atn.get_state(self.base.get_state());
if state.state_type() == ATNStateType::RuleStop {
if self.depth == depth {
return Ok(());
}
self.visit_rule_stop_state(state)?;
} else {
self.visit_state(state)?;
}
}
}
fn visit_state(&mut self, state: &'static ATNState) -> Result<(), ANTLRError> {
let mut alt = 1;
if state.is_decision_state() && state.get_transitions().len() > 1 {
alt = self.predict(state)?;
}
let transition = usize::try_from(alt - 1)
.ok()
.and_then(|index| state.get_transitions().get(index))
.ok_or_else(|| ANTLRError::no_alt(&mut self.base))?;
match transition.transition_type() {
TransitionType::Epsilon => {
if state.state_type() == ATNStateType::StarLoopEntry
&& state
.try_as::<StarLoopEntryState>()
.is_some_and(|entry| entry.is_precedence)
&& transition.get_target().state_type() != ATNStateType::LoopEnd
{
let (parent, parent_state) = *self
.parent_context_stack
.last()
.expect("left-recursive rule has a parent context");
let rule = self
.base
.ctx()
.expect("parser is inside a rule")
.get_rule_index();
let context = self.create_context(parent, parent_state, rule)?;
self.base.push_new_recursion_context(
context,
self.atn.rule_to_start_state[rule].get_state_number(),
rule,
)?;
}
}
TransitionType::Atom => {
let label = transition
.try_as::<dbt_antlr_runtime::transition::AtomTransition>()
.expect("atom transition")
.label();
self.base.match_token(label, &mut FailFast)?;
}
TransitionType::Range | TransitionType::Set | TransitionType::NotSet => {
let token = self.base.get_input_stream_mut().la(1);
if !transition.matches(token, TOKEN_MIN_USER_TOKEN_TYPE, self.atn.max_token_type) {
return Err(ANTLRError::input_mismatch(&mut self.base));
}
self.base.match_wildcard(&mut FailFast)?;
}
TransitionType::Wildcard => {
self.base.match_wildcard(&mut FailFast)?;
}
TransitionType::Rule => {
let rule_transition = transition
.try_as::<RuleTransition>()
.expect("rule transition");
let rule_start = transition.get_target();
let rule = usize::try_from(rule_start.get_rule_index()).unwrap_or(0);
if matches!(self.oracle, Oracle::Static(_))
&& self.base.resume_take(rule)?.is_some()
{
self.base
.set_state(rule_transition.follow_state.get_state_number());
return Ok(());
}
self.enter_rule_call(state.get_state_number(), rule, rule_transition.precedence())?;
return Ok(());
}
TransitionType::Predicate | TransitionType::Action => {}
TransitionType::PrecedencePredicate => {
let precedence = transition
.try_as::<PrecedencePredicateTransition>()
.expect("precedence predicate transition")
.precedence();
let context = self.base.ctx();
if !self.base.precpred(context, precedence) {
return Err(ANTLRError::failed_predicate(
&mut self.base,
Some(format!("precpred(_ctx, {precedence})")),
None,
));
}
}
}
self.base
.set_state(transition.get_target().get_state_number());
Ok(())
}
fn enter_rule_call(
&mut self,
invoking_state: i32,
rule: usize,
precedence: i32,
) -> Result<&'arena ExplainNode<'input, 'arena>, ANTLRError> {
let rule_start = self.atn.rule_to_start_state[rule];
let context = self.create_context(self.base.ctx(), invoking_state, rule)?;
let node = unsafe { &*std::ptr::from_ref(&*context) };
if is_left_recursive_rule(rule_start.as_ref()) {
self.enter_recursion_rule(context, rule_start.get_state_number(), rule, precedence)?;
} else {
self.base
.enter_rule(context, rule_start.get_state_number(), rule)?;
}
self.depth += 1;
Ok(node)
}
fn enter_recursion_rule(
&mut self,
context: &'arena mut ExplainNode<'input, 'arena>,
state: i32,
rule: usize,
precedence: i32,
) -> Result<(), ANTLRError> {
let pair = (self.base.ctx(), context.get_invoking_state());
self.parent_context_stack.push(pair);
self.base
.enter_recursion_rule(context, state, rule, precedence)
}
fn visit_rule_stop_state(&mut self, state: &'static ATNState) -> Result<(), ANTLRError> {
let rule_start =
self.atn.rule_to_start_state[usize::try_from(state.get_rule_index()).unwrap_or(0)];
if is_left_recursive_rule(rule_start.as_ref()) {
let (parent, parent_state) = self
.parent_context_stack
.pop()
.expect("left-recursive rule has a parent context");
self.base.unroll_recursion_context(parent)?;
self.base.set_state(parent_state);
} else {
self.base.exit_rule()?;
}
self.depth -= 1;
let invoking = self.atn.get_state(self.base.get_state());
let rule_transition = invoking
.get_transitions()
.first()
.and_then(|transition| transition.try_as::<RuleTransition>())
.expect("invoking state has a rule transition");
self.base
.set_state(rule_transition.follow_state.get_state_number());
Ok(())
}
fn create_context(
&self,
parent: Option<&'arena ExplainNode<'input, 'arena>>,
invoking_state: i32,
rule: usize,
) -> Result<&'arena mut ExplainNode<'input, 'arena>, ANTLRError> {
BaseParserRuleContext::create(
self.base.arena,
parent,
invoking_state,
InterpreterRuleContextExt::new(rule),
)
}
fn stack(&self) -> Vec<Frame> {
let mut frames = Vec::new();
let mut context = self.base.ctx();
while let Some(node) = context {
frames.push(Frame {
rule: node.get_rule_index(),
start: ParserRuleContext::start(node).get_token_index(),
});
context = node.get_parent();
}
frames.reverse();
frames
}
fn predict(&mut self, state: &'static ATNState) -> Result<i32, ANTLRError> {
let decision = usize::try_from(state.get_decision().unwrap_or(-1)).unwrap_or(usize::MAX);
let step = self.events.len();
if let Oracle::FullLl { probe: Some(probe) } = self.oracle
&& *probe == step
{
return self.run_probe(decision);
}
self.events.push(DecisionEvent {
decision,
rule: usize::try_from(state.get_rule_index()).unwrap_or(0),
token_index: self.base.get_input_stream().index(),
stack: self.stack(),
alt: None,
resolution: Resolution::Pending,
});
let predicted = match self.oracle {
Oracle::Static(oracle) => self.predict_static(oracle, state, decision),
Oracle::FullLl { .. } => self.adaptive(decision).map(|alt| (alt, Resolution::FullLl)),
};
match predicted {
Ok((alt, resolution)) => {
let event = &mut self.events[step];
event.alt = Some(alt);
event.resolution = resolution;
Ok(alt)
}
Err(error) => Err(error),
}
}
fn adaptive(&mut self, decision: usize) -> Result<i32, ANTLRError> {
let decision = i32::try_from(decision).unwrap_or(-1);
self.base
.get_interpreter()
.adaptive_predict(decision, &mut self.base)
}
fn run_probe(&mut self, decision: usize) -> Result<i32, ANTLRError> {
let interpreter = self.base.get_interpreter();
interpreter.set_prediction_mode(PredictionMode::SLL);
let sll = self.adaptive(decision).ok();
interpreter.set_prediction_mode(PredictionMode::LL);
self.probe = Some(sll);
Err(ANTLRError::custom_error(PROBE_DONE.to_owned()))
}
fn predict_static(
&mut self,
oracle: &StaticOracle<'_>,
state: &'static ATNState,
decision: usize,
) -> Result<(i32, Resolution), ANTLRError> {
let decision_number = i32::try_from(decision).unwrap_or(-1);
if let Some(lookahead) = oracle.ll1.get(&decision) {
return self.predict_ll1(state, lookahead);
}
if oracle.tables.has_table(decision) {
let walk = oracle
.results
.get(decision)
.and_then(|result| self.walk_table(result));
self.set_resolution(Resolution::Table(walk.clone().unwrap_or_else(unknown_walk)));
if let Some(plan) = oracle.tables.descent(decision) {
let virtual_alt = self.base.dfa_predict_virtual(decision_number)?;
if let Some(group) = plan
.groups
.iter()
.find(|group| group.virtual_alt == virtual_alt)
{
return self.shared_descent(oracle, decision, group, walk);
}
return self.table_alt(oracle, decision, virtual_alt, walk);
}
let alt = self.base.dfa_predict(decision_number)?;
return self.table_alt(oracle, decision, alt, walk);
}
if oracle.static_only {
return Err(self.no_static_table(decision));
}
self.adaptive(decision)
.map(|alt| (alt, Resolution::Adaptive))
}
fn set_resolution(&mut self, resolution: Resolution) {
if let Some(event) = self.events.last_mut() {
event.resolution = resolution;
}
}
fn no_static_table(&mut self, decision: usize) -> ANTLRError {
self.set_resolution(Resolution::NoStaticTable);
ANTLRError::custom_error(format!(
"decision {decision} has no static table: --static-dfa-only rejects it (G4S190)"
))
}
fn table_alt(
&mut self,
oracle: &StaticOracle<'_>,
decision: usize,
alt: i32,
walk: Option<TableWalk>,
) -> Result<(i32, Resolution), ANTLRError> {
if alt == INVALID_ALT {
if oracle.tables.defers(decision) {
if oracle.static_only {
return Err(self.no_static_table(decision));
}
let alt = self.adaptive(decision)?;
let mut walk = walk.unwrap_or_else(unknown_walk);
walk.kind = TableKind::Escape;
return Ok((alt, Resolution::Table(walk)));
}
return Err(ANTLRError::no_alt(&mut self.base));
}
let walk = walk.map_or_else(unknown_walk, |walk| checked_walk(walk, alt));
Ok((alt, Resolution::Table(walk)))
}
fn shared_descent(
&mut self,
oracle: &StaticOracle<'_>,
decision: usize,
group: &DescentGroup,
walk: Option<TableWalk>,
) -> Result<(i32, Resolution), ANTLRError> {
let group_number =
group.virtual_alt - dbt_antlr_runtime::dfa::static_parser_dfa::VIRTUAL_ALT_BASE;
if !self.base.descent_ready() {
let alt = if oracle.static_only {
group.min_alt()
} else {
self.adaptive(decision)?
};
return Ok((
alt,
Resolution::DescentFallback {
group: group_number,
},
));
}
let call_sites = *self
.call_sites
.entry((decision, group.virtual_alt))
.or_insert_with(|| Box::leak(group.call_sites.clone().into_boxed_slice()));
let step = self.events.len() - 1;
let neutral = self
.base
.begin_neutral_parse(call_sites, group.prefix.len());
let depth = self.depth;
let invoked = self
.enter_rule_call(self.base.get_state(), group.rule, group.precedence)
.and_then(|_| self.run_until(depth + 1))
.and_then(|()| self.finish_rule_call());
match invoked {
Ok(node) => {
let token = self.base.get_input_stream_mut().la(1);
let tail = self.base.get_input_stream().index();
let alt = group
.arms
.iter()
.find(|arm| arm.tokens.contains(&token))
.map_or_else(|| group.default_or_min_alt(), |arm| arm.alt);
self.base.resume_neutral_parse(neutral, node, group.rule);
Ok((
alt,
Resolution::Descent {
group: group_number,
rule: group.rule,
tail,
walk,
alts: group.alts.clone(),
neutral_end: self.events.len(),
},
))
}
Err(error) => {
self.base.abort_neutral_parse(neutral);
self.events[step].resolution = Resolution::DescentAborted {
group: group_number,
alts: group.alts.clone(),
walk,
};
Err(error)
}
}
}
fn finish_rule_call(&mut self) -> Result<&'arena ExplainNode<'input, 'arena>, ANTLRError> {
let state = self.atn.get_state(self.base.get_state());
let rule_start =
self.atn.rule_to_start_state[usize::try_from(state.get_rule_index()).unwrap_or(0)];
self.depth -= 1;
if is_left_recursive_rule(rule_start.as_ref()) {
let node = self.base.ctx().expect("parser is inside a rule");
let (parent, _) = self
.parent_context_stack
.pop()
.expect("left-recursive rule has a parent context");
self.base.unroll_recursion_context(parent)?;
Ok(node)
} else {
self.base.exit_rule()
}
}
fn predict_ll1(
&mut self,
state: &'static ATNState,
lookahead: &DecisionLookahead,
) -> Result<(i32, Resolution), ANTLRError> {
let token = self.base.get_input_stream_mut().la(1);
let exit = has_exit_alternative(state);
let entries = if exit {
lookahead.alternatives.len().saturating_sub(1)
} else {
lookahead.alternatives.len()
};
let matched = lookahead.alternatives[..entries]
.iter()
.position(|alternative| {
alternative.as_ref().is_some_and(|ranges| {
ranges.iter().any(|(lo, hi)| (*lo..=*hi).contains(&token))
})
});
if let Some(index) = matched {
let alt = i32::try_from(index + 1).unwrap_or(INVALID_ALT);
return Ok((alt, Resolution::Ll1 { matched: true }));
}
self.set_resolution(Resolution::Ll1 { matched: false });
if exit {
let alt = i32::try_from(state.get_transitions().len()).unwrap_or(INVALID_ALT);
return Ok((alt, Resolution::Ll1 { matched: false }));
}
Err(ANTLRError::no_alt(&mut self.base))
}
fn walk_table(&mut self, result: &DecisionOutcome) -> Option<TableWalk> {
let precedence = self.base.get_precedence().max(0);
let (table, class) = match (&result.table, &result.precedence) {
(Some(table), _) => (table, None),
(None, Some(classes)) => {
let class = classes
.cutoffs
.iter()
.take_while(|cutoff| **cutoff < precedence)
.count();
(classes.tables.get(class)?.as_ref()?, Some(class))
}
(None, None) => return None,
};
let mut state = 0_usize;
let mut lookahead = Vec::new();
let mut stopped_on_edge = false;
if table.states.first()?.accept == 0 {
let stream = self.base.get_input_stream_mut();
let start = stream.index();
let mark = stream.mark();
loop {
let token = stream.la(1);
let Some(edge) = table.states.get(state).and_then(|entry| {
entry
.edges
.iter()
.find(|edge| edge.lo <= token && token <= edge.hi)
}) else {
break;
};
lookahead.push(stream.lt(1).map_or(-1, |token| token.get_token_index()));
state = edge.target;
if table
.states
.get(state)
.is_none_or(|entry| entry.accept != 0)
{
stopped_on_edge = true;
break;
}
if token == TOKEN_EOF {
break;
}
stream.consume();
}
stream.seek(start);
stream.release(mark);
}
table
.states
.get(state)
.map(|_| classify_walk(table, class, state, lookahead, stopped_on_edge))
}
fn syntax_error(&mut self, error: &ANTLRError) -> SyntaxError {
let (kind, base) = match error.as_ref() {
ANTLRErrorKind::NoAltError(error) => (ErrorKind::NoViableAlt, Some(&error.base)),
ANTLRErrorKind::InputMismatchError(error) => (ErrorKind::Mismatch, Some(&error.base)),
ANTLRErrorKind::PredicateError(error) => {
(ErrorKind::FailedPredicate, Some(&error.base))
}
_ => (ErrorKind::Other, None),
};
let token_index = error.get_offending_token().map_or_else(
|| self.base.get_input_stream().index(),
|token| token.get_token_index(),
);
let expected = base.map_or_else(Vec::new, |base| {
let set = base.get_expected_tokens(&self.base);
set.as_slice()
.iter()
.flat_map(|interval| interval.a..=interval.b)
.collect()
});
let step = self
.events
.last()
.filter(|event| event.alt.is_none())
.map(|_| self.events.len() - 1);
SyntaxError {
kind,
token_index,
expected,
stack: self.stack(),
step,
message: match error.as_ref() {
ANTLRErrorKind::CustomError(message)
| ANTLRErrorKind::IllegalStateError(message) => message.clone(),
_ if kind == ErrorKind::Other => error.to_string(),
_ => String::new(),
},
}
}
}
fn unknown_walk() -> TableWalk {
TableWalk {
class: None,
state: 0,
lookahead: Vec::new(),
kind: TableKind::Unknown,
dropped: Vec::new(),
expected: None,
guard: None,
}
}
fn classify_walk(
table: &StaticDfaTable,
class: Option<usize>,
state: usize,
lookahead: Vec<isize>,
stopped_on_edge: bool,
) -> TableWalk {
let entry = &table.states[state];
let without = |alts: &[i32]| -> Vec<i32> {
alts.iter()
.copied()
.filter(|alt| *alt != entry.accept)
.collect()
};
let guard = entry
.is_guarded()
.then_some((entry.guarded_alt, entry.guard_defer_alt));
let (kind, dropped) = match entry.resolution {
Some(EscapeResolution::MinAlt) => (TableKind::MinAlt, without(&entry.conflicts)),
Some(EscapeResolution::MinViableAlt) => {
(TableKind::MinViableAlt, without(&entry.viable_alts))
}
Some(EscapeResolution::SyntaxError) => (TableKind::SyntaxError, Vec::new()),
Some(EscapeResolution::Guarded) => (TableKind::GuardTaken, Vec::new()),
None if entry.is_guarded() => (TableKind::GuardTaken, Vec::new()),
None if entry.is_accept() => (TableKind::Exact, Vec::new()),
None if entry.is_escape() => (TableKind::Escape, Vec::new()),
None if !stopped_on_edge && entry.fallback > 0 => (TableKind::Fallback, Vec::new()),
None => (TableKind::Unknown, Vec::new()),
};
let expected = match kind {
TableKind::Exact | TableKind::MinAlt | TableKind::MinViableAlt => Some(entry.accept),
TableKind::Fallback => Some(entry.fallback),
_ => None,
};
TableWalk {
class,
state,
lookahead,
kind,
dropped,
expected,
guard,
}
}
fn checked_walk(mut walk: TableWalk, alt: i32) -> TableWalk {
if let Some((taken, deferred)) = walk.guard {
walk.kind = if alt == deferred && alt != taken {
TableKind::GuardDeferred
} else {
TableKind::GuardTaken
};
} else if walk.expected.is_some_and(|expected| expected != alt) {
walk.kind = TableKind::Unknown;
walk.dropped.clear();
}
walk
}
fn has_exit_alternative(state: &ATNState) -> bool {
match state.state_type() {
ATNStateType::StarLoopEntry | ATNStateType::PlusLoopBack => true,
_ => state.get_transitions().last().is_some_and(|transition| {
transition.get_target().state_type() == ATNStateType::BlockEnd
}),
}
}
fn is_left_recursive_rule(rule_start: &ATNState) -> bool {
rule_start
.try_as::<RuleStartState>()
.is_some_and(|state| state.is_left_recursive)
}