) {
+ debug_assert_eq!(state.get_state_number(), self.states.len());
+ self.states.push(state)
+ }
+
+ // fn remove_state(&self, _state: ATNStateRef) { unimplemented!() }
+
+ // fn define_decision_state(&self, _s: ATNStateRef) -> isize { unimplemented!() }
+
+ pub fn get_decision_state(&self, decision: usize) -> ATNStateRef {
+ self.decision_to_state[decision]
+ }
+
+ /// Computes the set of input symbols which could follow ATN state number
+ /// {@code stateNumber} in the specified full {@code context}. This method
+ /// considers the complete parser context, but does not evaluate semantic
+ /// predicates (i.e. all predicates encountered during the calculation are
+ /// assumed true). If a path in the ATN exists from the starting state to the
+ /// {@link RuleStopState} of the outermost context without matching any
+ /// symbols, {@link Token#EOF} is added to the returned set.
+ ///
+ /// If {@code context} is {@code null}, it is treated as {@link ParserRuleContext#EMPTY}.
+ ///
+ /// Note that this does NOT give you the set of all tokens that could
+ /// appear at a given token position in the input phrase. In other words,
+ /// it does not answer:
+ ///
+ /// "Given a specific partial input phrase, return the set of all tokens
+ /// that can follow the last token in the input phrase."
+ ///
+ /// The big difference is that with just the input, the parser could
+ /// land right in the middle of a lookahead decision. Getting
+ /// all *possible* tokens given a partial input stream is a separate
+ /// computation. See https://github.com/antlr/antlr4/issues/1428
+ ///
+ /// For this function, we are specifying an ATN state and call stack to compute
+ /// what token(s) can come next and specifically: outside of a lookahead decision.
+ /// That is what you want for error reporting and recovery upon parse error.
+ ///
+ /// @param stateNumber the ATN state number
+ /// @param context the full parse context
+ /// @return The set of potentially valid input symbols which could follow the
+ /// specified state in the specified context.
+ /// Panics if the ATN does not contain a state with
+ /// number {@code stateNumber}
+ pub fn get_expected_tokens(
+ &self,
+ state_number: isize,
+ states_stack: impl Iterator- , // _ctx: &Rc,
+ ) -> IntervalSet {
+ let s = self.states[state_number as usize].as_ref();
+ let mut following = self.next_tokens(s);
+ if !following.contains(TOKEN_EPSILON) {
+ return following.clone();
+ }
+ let mut expected = IntervalSet::new();
+ expected.add_set(&following);
+ expected.remove_one(TOKEN_EPSILON);
+ // let mut ctx = Some(Rc::clone(_ctx));
+
+ for state in states_stack {
+ if !following.contains(TOKEN_EPSILON) {
+ break;
+ }
+
+ let invoking_state = self.states[state as usize].as_ref();
+ let tr = invoking_state.get_transitions().first().unwrap().as_ref();
+ let tr = tr.cast::();
+ following = self.next_tokens(self.states[tr.follow_state].as_ref());
+ expected.add_set(following);
+ expected.remove_one(TOKEN_EPSILON);
+ // ctx = c.get_parent_ctx();
+ }
+
+ if following.contains(TOKEN_EPSILON) {
+ expected.add_one(TOKEN_EOF);
+ }
+ expected
+ }
+}
diff --git a/runtime/Rust/src/atn_config.rs b/runtime/Rust/src/atn_config.rs
new file mode 100644
index 0000000000..c430184529
--- /dev/null
+++ b/runtime/Rust/src/atn_config.rs
@@ -0,0 +1,261 @@
+use std::fmt::{Debug, Error, Formatter};
+use std::hash::{Hash, Hasher};
+use std::rc::Rc;
+
+use murmur3::murmur3_32::MurmurHasher;
+
+use crate::atn_config::ATNConfigType::LexerATNConfig;
+use crate::atn_state::{ATNState, ATNStateRef, ATNStateType};
+use crate::dfa::ScopeExt;
+use crate::lexer_action_executor::LexerActionExecutor;
+use crate::prediction_context::PredictionContext;
+use crate::semantic_context::SemanticContext;
+
+#[derive(Clone)]
+pub struct ATNConfig {
+ precedence_filter_suppressed: bool,
+ //todo since ATNState is immutable when we started working with ATNConfigs
+ // looks like it is possible to have usual reference here
+ state: ATNStateRef,
+ alt: isize,
+ //todo maybe option is unnecessary and PredictionContext::EMPTY would be enough
+ //another todo check arena alloc
+ context: Option>,
+ pub semantic_context: Box,
+ pub reaches_into_outer_context: isize,
+ pub(crate) config_type: ATNConfigType,
+}
+
+impl Eq for ATNConfig {}
+
+impl PartialEq for ATNConfig {
+ fn eq(&self, other: &Self) -> bool {
+ self.get_state() == other.get_state()
+ && self.get_alt() == other.get_alt()
+ // Rc is optimized to not do a deep equalitiy if arc pointers are equal so that's enough
+ && self.context == other.context
+ && self.get_type() == other.get_type()
+ && self.semantic_context == other.semantic_context
+ && self.precedence_filter_suppressed == other.precedence_filter_suppressed
+ }
+}
+
+impl Hash for ATNConfig {
+ fn hash(&self, state: &mut H) {
+ state.write_i32(self.get_state() as i32);
+ state.write_i32(self.get_alt() as i32);
+ match self.get_context() {
+ None => state.write_i32(0),
+ Some(c) => c.hash(state),
+ }
+ self.semantic_context.hash(state);
+ if let LexerATNConfig {
+ lexer_action_executor,
+ passed_through_non_greedy_decision,
+ } = &self.config_type
+ {
+ state.write_i32(if *passed_through_non_greedy_decision {
+ 1
+ } else {
+ 0
+ });
+ match lexer_action_executor {
+ None => state.write_i32(0),
+ Some(ex) => ex.hash(state),
+ }
+ }
+ }
+}
+
+impl Debug for ATNConfig {
+ fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+ f.write_fmt(format_args!(
+ "({},{},[{}]",
+ self.state,
+ self.alt,
+ self.context.as_deref().unwrap()
+ ))?;
+ if self.reaches_into_outer_context > 0 {
+ f.write_fmt(format_args!(",up={}", self.reaches_into_outer_context))?;
+ }
+
+ f.write_str(")")
+ }
+}
+
+#[derive(Eq, PartialEq, Clone, Debug)]
+pub(crate) enum ATNConfigType {
+ BaseATNConfig,
+ LexerATNConfig {
+ lexer_action_executor: Option>,
+ passed_through_non_greedy_decision: bool,
+ },
+}
+
+impl ATNConfig {
+ pub(crate) fn get_lexer_executor(&self) -> Option<&LexerActionExecutor> {
+ match &self.config_type {
+ ATNConfigType::BaseATNConfig => None,
+ ATNConfigType::LexerATNConfig {
+ lexer_action_executor,
+ ..
+ } => lexer_action_executor.as_deref(),
+ }
+ }
+
+ pub fn default_hash(&self) -> u64 {
+ MurmurHasher::default().convert_with(|mut x| {
+ self.hash(&mut x);
+ x.finish()
+ })
+ }
+
+ pub fn new(
+ state: ATNStateRef,
+ alt: isize,
+ context: Option>,
+ ) -> ATNConfig {
+ ATNConfig {
+ precedence_filter_suppressed: false,
+ state,
+ alt,
+ context,
+ semantic_context: Box::new(SemanticContext::NONE),
+ reaches_into_outer_context: 0,
+ config_type: ATNConfigType::BaseATNConfig,
+ }
+ }
+
+ pub fn new_with_semantic(
+ state: ATNStateRef,
+ alt: isize,
+ context: Option>,
+ semantic_context: Box,
+ ) -> ATNConfig {
+ let mut new = Self::new(state, alt, context);
+ new.semantic_context = semantic_context;
+ new
+ }
+
+ pub fn new_lexer_atnconfig6(
+ _state: ATNStateRef,
+ _alt: isize,
+ _context: Rc,
+ ) -> ATNConfig {
+ let mut atnconfig = ATNConfig::new(_state, _alt, Some(_context));
+ atnconfig.config_type = ATNConfigType::LexerATNConfig {
+ lexer_action_executor: None,
+ passed_through_non_greedy_decision: false,
+ };
+ atnconfig
+ }
+
+ pub fn cloned_with_new_semantic(
+ &self,
+ target: &dyn ATNState,
+ ctx: Box,
+ ) -> ATNConfig {
+ let mut new = self.cloned(target);
+ new.semantic_context = ctx;
+ new
+ }
+
+ pub fn cloned(&self, target: &dyn ATNState) -> ATNConfig {
+ // println!("depth {}",PredictionContext::size(self.context.as_deref()));
+ let mut new = self.clone();
+ new.state = target.get_state_number();
+ if let ATNConfigType::LexerATNConfig {
+ passed_through_non_greedy_decision,
+ ..
+ } = &mut new.config_type
+ {
+ *passed_through_non_greedy_decision = check_non_greedy_decision(self, target);
+ }
+ new
+ }
+
+ pub fn cloned_with_new_ctx(
+ &self,
+ target: &dyn ATNState,
+ ctx: Option>,
+ ) -> ATNConfig {
+ let mut new = self.cloned(target);
+ new.context = ctx;
+
+ new
+ }
+
+ pub(crate) fn cloned_with_new_exec(
+ &self,
+ target: &dyn ATNState,
+ exec: Option,
+ ) -> ATNConfig {
+ let mut new = self.cloned(target);
+ if let ATNConfigType::LexerATNConfig {
+ lexer_action_executor,
+ passed_through_non_greedy_decision: _,
+ } = &mut new.config_type
+ {
+ *lexer_action_executor = exec.map(Box::new);
+ // *passed_through_non_greedy_decision = check_non_greedy_decision(self, target);
+ }
+ new
+ }
+
+ pub fn get_state(&self) -> ATNStateRef {
+ self.state
+ }
+
+ pub fn get_alt(&self) -> isize {
+ self.alt
+ }
+
+ pub(crate) fn get_type(&self) -> &ATNConfigType {
+ &self.config_type
+ }
+
+ pub fn get_context(&self) -> Option<&Rc> {
+ self.context.as_ref()
+ }
+
+ pub fn take_context(&mut self) -> Rc {
+ self.context.take().unwrap()
+ }
+
+ pub fn set_context(&mut self, _v: Rc) {
+ self.context = Some(_v);
+ }
+
+ pub fn get_reaches_into_outer_context(&self) -> isize {
+ self.reaches_into_outer_context
+ }
+
+ pub fn set_reaches_into_outer_context(&mut self, _v: isize) {
+ self.reaches_into_outer_context = _v
+ }
+
+ pub fn is_precedence_filter_suppressed(&self) -> bool {
+ self.precedence_filter_suppressed
+ }
+
+ pub fn set_precedence_filter_suppressed(&mut self, _v: bool) {
+ self.precedence_filter_suppressed = _v;
+ }
+}
+
+fn check_non_greedy_decision(source: &ATNConfig, target: &dyn ATNState) -> bool {
+ if let LexerATNConfig {
+ passed_through_non_greedy_decision: true,
+ ..
+ } = source.get_type()
+ {
+ return true;
+ }
+ if let ATNStateType::DecisionState {
+ nongreedy: true, ..
+ } = target.get_state_type()
+ {
+ return true;
+ }
+ false
+}
diff --git a/runtime/Rust/src/atn_config_set.rs b/runtime/Rust/src/atn_config_set.rs
new file mode 100644
index 0000000000..d4eea7ca20
--- /dev/null
+++ b/runtime/Rust/src/atn_config_set.rs
@@ -0,0 +1,257 @@
+use std::cmp::max;
+use std::collections::HashMap;
+use std::fmt::{Debug, Error, Formatter};
+use std::hash::{Hash, Hasher};
+use std::ops::Deref;
+
+use bit_set::BitSet;
+use murmur3::murmur3_32::MurmurHasher;
+
+use crate::atn_config::ATNConfig;
+use crate::atn_simulator::IATNSimulator;
+use crate::atn_state::ATNStateRef;
+use crate::parser_atn_simulator::MergeCache;
+use crate::prediction_context::{MurmurHasherBuilder, PredictionContext};
+use crate::semantic_context::SemanticContext;
+
+pub struct ATNConfigSet {
+ cached_hash: u64,
+
+ //todo looks like we need only iteration for configs
+ // so i think we can replace configs and lookup with indexhashset
+ config_lookup: HashMap,
+
+ //todo remove box?
+ pub(crate) configs: Vec>,
+
+ pub(crate) conflicting_alts: BitSet,
+
+ dips_into_outer_context: bool,
+
+ full_ctx: bool,
+
+ has_semantic_context: bool,
+
+ read_only: bool,
+
+ unique_alt: isize,
+
+ /// creates key for lookup
+ /// Key::Full - for Lexer
+ /// Key::Partial - for Parser
+ hasher: fn(&ATNConfig) -> Key,
+}
+
+#[derive(Eq, PartialEq)]
+enum Key {
+ Full(ATNConfig),
+ Partial(i32, ATNStateRef, isize, SemanticContext),
+}
+
+impl Hash for Key {
+ fn hash(&self, state: &mut H) {
+ match self {
+ Key::Full(x) => x.hash(state),
+ Key::Partial(hash, _, _, _) => state.write_i32(*hash),
+ }
+ }
+}
+
+impl Debug for ATNConfigSet {
+ fn fmt(&self, _f: &mut Formatter<'_>) -> Result<(), Error> {
+ _f.write_str("ATNConfigSet")?;
+ _f.debug_list().entries(self.configs.iter()).finish()?;
+ if self.has_semantic_context {
+ _f.write_str(",hasSemanticContext=true")?
+ }
+ if self.conflicting_alts.is_empty() {
+ _f.write_fmt(format_args!(",uniqueAlt={}", self.unique_alt))
+ } else {
+ _f.write_fmt(format_args!(",conflictingAlts={:?}", self.conflicting_alts))
+ }
+ }
+}
+
+impl PartialEq for ATNConfigSet {
+ fn eq(&self, other: &Self) -> bool {
+ self.configs == other.configs
+ && self.full_ctx == other.full_ctx
+ && self.unique_alt == other.unique_alt
+ && self.conflicting_alts == other.conflicting_alts
+ && self.has_semantic_context == other.has_semantic_context
+ && self.dips_into_outer_context == other.dips_into_outer_context
+ }
+}
+
+impl Eq for ATNConfigSet {}
+
+impl Hash for ATNConfigSet {
+ fn hash(&self, state: &mut H) {
+ self.configs.hash(state)
+ }
+}
+
+impl ATNConfigSet {
+ pub fn new_base_atnconfig_set(full_ctx: bool) -> ATNConfigSet {
+ ATNConfigSet {
+ cached_hash: 0,
+ config_lookup: HashMap::with_hasher(MurmurHasherBuilder {}),
+ configs: vec![],
+ conflicting_alts: Default::default(),
+ dips_into_outer_context: false,
+ full_ctx,
+ has_semantic_context: false,
+ read_only: false,
+ unique_alt: 0,
+ hasher: Self::local_hash_key,
+ }
+ }
+
+ // for lexerATNConfig
+ pub fn new_ordered() -> ATNConfigSet {
+ let mut a = ATNConfigSet::new_base_atnconfig_set(true);
+
+ a.hasher = Self::full_hash_key;
+ a
+ }
+
+ fn full_hash_key(config: &ATNConfig) -> Key {
+ Key::Full(config.clone())
+ }
+
+ fn local_hash_key(config: &ATNConfig) -> Key {
+ let mut hasher = MurmurHasher::default();
+ config.get_state().hash(&mut hasher);
+ config.get_alt().hash(&mut hasher);
+ config.semantic_context.hash(&mut hasher);
+
+ Key::Partial(
+ hasher.finish() as i32,
+ config.get_state(),
+ config.get_alt(),
+ config.semantic_context.deref().clone(),
+ )
+ }
+
+ pub fn add_cached(
+ &mut self,
+ config: Box,
+ mut merge_cache: Option<&mut MergeCache>,
+ ) -> bool {
+ assert!(!self.read_only);
+
+ if *config.semantic_context != SemanticContext::NONE {
+ self.has_semantic_context = true
+ }
+
+ if config.get_reaches_into_outer_context() > 0 {
+ self.dips_into_outer_context = true
+ }
+
+ let hasher = self.hasher;
+ let key = hasher(config.as_ref());
+
+ if let Some(existing) = self.config_lookup.get(&key) {
+ let existing = self.configs.get_mut(*existing).unwrap().as_mut();
+ let root_is_wildcard = !self.full_ctx;
+
+ let merged = PredictionContext::merge(
+ existing.get_context().unwrap(),
+ config.get_context().unwrap(),
+ root_is_wildcard,
+ &mut merge_cache,
+ );
+
+ existing.set_reaches_into_outer_context(max(
+ existing.get_reaches_into_outer_context(),
+ config.get_reaches_into_outer_context(),
+ ));
+
+ if config.is_precedence_filter_suppressed() {
+ existing.set_precedence_filter_suppressed(true)
+ }
+
+ existing.set_context(merged);
+ } else {
+ self.config_lookup.insert(key, self.configs.len());
+ self.cached_hash = 0;
+ self.configs.push(config);
+ }
+ true
+ }
+
+ pub fn add(&mut self, config: Box) -> bool {
+ self.add_cached(config, None)
+ }
+
+ pub fn get_items(&self) -> impl Iterator
- {
+ self.configs.iter().map(|c| c.as_ref())
+ }
+
+ pub fn optimize_configs(&mut self, _interpreter: &dyn IATNSimulator) {
+ if self.configs.is_empty() {
+ return;
+ }
+
+ for config in self.configs.iter_mut() {
+ let mut visited = HashMap::new();
+ config.set_context(
+ _interpreter
+ .shared_context_cache()
+ .get_shared_context(config.get_context().unwrap(), &mut visited),
+ );
+ }
+ }
+
+ pub fn length(&self) -> usize {
+ self.configs.len()
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.configs.is_empty()
+ }
+
+ pub fn has_semantic_context(&self) -> bool {
+ self.has_semantic_context
+ }
+
+ pub fn set_has_semantic_context(&mut self, _v: bool) {
+ self.has_semantic_context = _v;
+ }
+
+ pub fn read_only(&self) -> bool {
+ self.read_only
+ }
+
+ pub fn set_read_only(&mut self, _read_only: bool) {
+ self.read_only = _read_only;
+ }
+
+ pub fn full_context(&self) -> bool {
+ self.full_ctx
+ }
+
+ //duplicate of the self.conflicting_alts???
+ pub fn get_alts(&self) -> BitSet {
+ self.configs.iter().fold(BitSet::new(), |mut acc, c| {
+ acc.insert(c.get_alt() as usize);
+ acc
+ })
+ }
+
+ pub fn get_unique_alt(&self) -> isize {
+ self.unique_alt
+ }
+
+ pub fn set_unique_alt(&mut self, _v: isize) {
+ self.unique_alt = _v
+ }
+
+ pub fn get_dips_into_outer_context(&self) -> bool {
+ self.dips_into_outer_context
+ }
+
+ pub fn set_dips_into_outer_context(&mut self, _v: bool) {
+ self.dips_into_outer_context = _v
+ }
+}
diff --git a/runtime/Rust/src/atn_deserialization_options.rs b/runtime/Rust/src/atn_deserialization_options.rs
new file mode 100644
index 0000000000..34c8890d5c
--- /dev/null
+++ b/runtime/Rust/src/atn_deserialization_options.rs
@@ -0,0 +1,23 @@
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct ATNDeserializationOptions {
+ read_only: bool,
+ verify_atn: bool,
+ generate_rule_bypass_transitions: bool,
+}
+
+impl ATNDeserializationOptions {
+ pub fn is_verify(&self) -> bool {
+ self.verify_atn
+ }
+}
+
+impl Default for ATNDeserializationOptions {
+ fn default() -> Self {
+ ATNDeserializationOptions {
+ read_only: true,
+ verify_atn: true,
+ generate_rule_bypass_transitions: false,
+ }
+ }
+}
diff --git a/runtime/Rust/src/atn_deserializer.rs b/runtime/Rust/src/atn_deserializer.rs
new file mode 100644
index 0000000000..593da836f4
--- /dev/null
+++ b/runtime/Rust/src/atn_deserializer.rs
@@ -0,0 +1,614 @@
+use std::str::Chars;
+use std::str::FromStr;
+
+use byteorder::LittleEndian;
+use byteorder::WriteBytesExt;
+use uuid::Uuid;
+
+use crate::atn::ATN;
+use crate::atn_deserialization_options::ATNDeserializationOptions;
+use crate::atn_state::ATNBlockStart;
+use crate::atn_state::ATNDecisionState;
+use crate::atn_state::ATNState;
+use crate::atn_state::ATNStateType;
+use crate::atn_state::BaseATNState;
+use crate::atn_state::*;
+use crate::atn_type::ATNType;
+use crate::int_stream::EOF;
+use crate::interval_set::IntervalSet;
+use crate::lexer_action::LexerAction::*;
+use crate::lexer_action::*;
+use crate::transition::Transition;
+use crate::transition::*;
+
+lazy_static! {
+ static ref BASE_SERIALIZED_UUID: Uuid =
+ Uuid::from_str("33761B2D-78BB-4A43-8B0B-4F5BEE8AACF3").unwrap();
+ static ref ADDED_PRECEDENCE_TRANSITIONS: Uuid =
+ Uuid::from_str("1DA0C57D-6C06-438A-9B27-10BCB3CE0F61").unwrap();
+ static ref ADDED_LEXER_ACTIONS: Uuid =
+ Uuid::from_str("AADB8D7E-AEEF-4415-AD2B-8204D6CF042E").unwrap();
+ static ref ADDED_UNICODE_SMP: Uuid =
+ Uuid::from_str("59627784-3BE5-417A-B9EB-8131A7286089").unwrap();
+ static ref SUPPORTED_UUIDS: Vec = vec![
+ *BASE_SERIALIZED_UUID,
+ *ADDED_PRECEDENCE_TRANSITIONS,
+ *ADDED_LEXER_ACTIONS,
+ *ADDED_UNICODE_SMP,
+ ];
+}
+
+const SERIALIZED_VERSION: isize = 3;
+
+#[derive(Debug)]
+pub struct ATNDeserializer {
+ deserialization_options: ATNDeserializationOptions,
+}
+
+impl ATNDeserializer {
+ pub fn new(options: Option) -> ATNDeserializer {
+ ATNDeserializer {
+ deserialization_options: options.unwrap_or(ATNDeserializationOptions::default()),
+ }
+ }
+
+ pub fn deserialize(&self, data: Chars<'_>) -> ATN {
+ let mut data = data.clone().map(|ch| {
+ let mut ch = ch as isize;
+ // decode surrogates
+ ch = if ch > 0xFFFF { ch - 0x3000 } else { ch };
+ ch -= 2;
+ ch
+ });
+
+ self.check_version(data.next().unwrap() + 2);
+
+ let _uuid = self.check_uuid(&mut data);
+
+ let mut atn = self.read_atn(&mut data);
+
+ self.read_states(&mut atn, &mut data);
+ self.read_rules(&mut atn, &mut data);
+ self.read_modes(&mut atn, &mut data);
+
+ let mut sets = self.read_sets(&mut atn, &mut data, |data| {
+ data.next().unwrap() as u16 as isize
+ });
+
+ sets.extend(self.read_sets(&mut atn, &mut data, |data| {
+ (data.next().unwrap() & 0xFFFF) | data.next().unwrap() << 16
+ }));
+
+ self.read_edges(&mut atn, &mut data, &sets);
+ self.read_decisions(&mut atn, &mut data);
+ if atn.grammar_type == ATNType::LEXER {
+ self.read_lexer_actions(&mut atn, &mut data);
+ }
+ self.mark_precedence_decisions(&mut atn, &mut data);
+ if self.deserialization_options.is_verify() {
+ self.verify_atn(&mut atn, &mut data);
+ }
+ // TODO parser
+ // if a.deserializationOptions.generateRuleBypassTransitions && atn.grammarType == ATNTypeParser {
+ // a.generateRuleBypassTransitions(atn)
+ // a.verifyATN(atn)
+ // }
+
+ atn
+ }
+
+ // fn reset(&self, _data: Vec) { unimplemented!() }
+
+ fn check_version(&self, version: isize) {
+ if version != self::SERIALIZED_VERSION {
+ panic!(
+ "Could not deserialize ATN with version {} (expected {})",
+ version, SERIALIZED_VERSION
+ );
+ }
+ }
+
+ fn check_uuid(&self, data: &mut dyn Iterator
- ) -> Uuid {
+ //rust uses UTF-8 encoding so we need explicitly convert unicode
+ //codepoint numbers to bytes
+ let mut bytes = Vec::new();
+ for i in data.take(8) {
+ bytes.write_u16::(i as u16).unwrap();
+ }
+
+ bytes.reverse();
+ let uuid = Uuid::from_slice(&bytes).unwrap();
+ if !SUPPORTED_UUIDS.contains(&uuid) {
+ panic!("Could not deserialize ATN with UUID {}", uuid)
+ }
+ uuid
+ }
+
+ fn read_atn(&self, data: &mut dyn Iterator
- ) -> ATN {
+ let atn = ATN::new_atn(
+ match data.next() {
+ Some(0) => ATNType::LEXER,
+ Some(1) => ATNType::PARSER,
+ _ => panic!("invalid ATN type"),
+ },
+ data.next().unwrap(),
+ );
+
+ atn
+ }
+
+ fn read_states(&self, atn: &mut ATN, data: &mut dyn Iterator
- ) {
+ // let loop_back_states = Vec::<(BaseATNState,isize)>::new();
+ // let end_states = Vec::<(BaseATNState,isize)>::new();
+ let states_count = data.next().unwrap() as usize;
+ for i in 0..states_count {
+ let state_type = data.next().unwrap();
+ if state_type == ATNSTATE_INVALID_STATE_NUMBER {
+ atn.add_state(self.state_factory(ATNSTATE_INVALID_TYPE, -1, i));
+ panic!("why invalid state serialized?");
+ }
+
+ let mut rule_index = data.next().unwrap();
+ if rule_index == 0xFFFF {
+ rule_index = -1;
+ }
+ let mut state = self.state_factory(state_type, rule_index, i);
+
+ match state.get_state_type_mut() {
+ ATNStateType::DecisionState {
+ state: ATNDecisionState::BlockStartState { end_state, .. },
+ ..
+ } => *end_state = data.next().unwrap() as ATNStateRef,
+ ATNStateType::LoopEndState(loop_back) => {
+ *loop_back = data.next().unwrap() as ATNStateRef
+ }
+ _ => (),
+ }
+ atn.add_state(state);
+ }
+
+ let num_non_greedy = data.next().unwrap();
+ //println!("num_non_greedy {}", num_non_greedy);
+ for _ in 0..num_non_greedy {
+ let st = data.next().unwrap() as usize;
+ if let ATNStateType::DecisionState { nongreedy: ng, .. } =
+ atn.states[st].get_state_type_mut()
+ {
+ *ng = true
+ }
+ }
+
+ //if (supportsPrecedencePredicates)
+ if true {
+ let num_precedence_states = data.next().unwrap();
+ for _ in 0..num_precedence_states {
+ let st = data.next().unwrap() as usize;
+ if let ATNStateType::RuleStartState {
+ is_left_recursive: left_rec,
+ ..
+ } = atn.states[st].get_state_type_mut()
+ {
+ *left_rec = true
+ }
+ }
+ }
+ }
+
+ fn read_rules(&self, atn: &mut ATN, data: &mut dyn Iterator
- ) {
+ let nrules = data.next().unwrap() as usize;
+ // if atn.grammar_type == ATNType::LEXER {
+ // atn.rule_to_token_type.resize(nrules, 0)
+ // }
+
+ atn.rule_to_start_state.resize(nrules, 0);
+ for i in 0..nrules {
+ let s = data.next().unwrap() as usize;
+ atn.rule_to_start_state[i] = s;
+ if atn.grammar_type == ATNType::LEXER {
+ let token_type = data.next().unwrap();
+
+ atn.rule_to_token_type.push(token_type);
+ }
+ }
+ //println!("rule_to_token_type {:?}", atn.rule_to_token_type);
+ //println!("rule_to_start_state {:?}", atn.rule_to_start_state);
+
+ atn.rule_to_stop_state.resize(nrules, 0);
+ for i in 0..atn.states.len() {
+ let state = atn.states.get(i).unwrap();
+ if let ATNStateType::RuleStopState = state.get_state_type() {
+ let rule_index = state.get_rule_index();
+ atn.rule_to_stop_state[rule_index] = i;
+ let start_state = atn
+ .states
+ .get_mut(atn.rule_to_start_state[rule_index])
+ .unwrap();
+ if let ATNStateType::RuleStartState {
+ stop_state: stop, ..
+ } = start_state.get_state_type_mut()
+ {
+ *stop = i
+ }
+ }
+ }
+ }
+
+ fn read_modes(&self, atn: &mut ATN, data: &mut dyn Iterator
- ) {
+ let nmodes = data.next().unwrap();
+ for _i in 0..nmodes {
+ atn.mode_to_start_state.push(data.next().unwrap() as usize);
+ }
+ }
+
+ fn read_sets>(
+ &self,
+ _atn: &mut ATN,
+ data: &mut T,
+ read_unicode: fn(&mut T) -> isize,
+ ) -> Vec {
+ let nsets = data.next().unwrap();
+ let mut sets = Vec::new();
+ for _i in 0..nsets {
+ let intervals = data.next().unwrap();
+
+ let mut set = IntervalSet::new();
+
+ // check if contains eof
+ if data.next().unwrap() != 0 {
+ set.add_one(-1)
+ }
+
+ for _ in 0..intervals {
+ set.add_range(read_unicode(data), read_unicode(data));
+ }
+ sets.push(set);
+ }
+
+ sets
+ }
+
+ fn read_edges(
+ &self,
+ atn: &mut ATN,
+ data: &mut dyn Iterator
- ,
+ sets: &Vec,
+ ) {
+ let nedges = data.next().unwrap();
+
+ for _i in 0..nedges {
+ let src = data.next().unwrap() as usize;
+ let trg = data.next().unwrap() as usize;
+ let ttype = data.next().unwrap();
+ let arg1 = data.next().unwrap();
+ let arg2 = data.next().unwrap();
+ let arg3 = data.next().unwrap();
+
+ let transition = self.edge_factory(atn, ttype, src, trg, arg1, arg2, arg3, sets);
+
+ atn.states.get_mut(src).unwrap().add_transition(transition);
+ }
+
+ let mut new_tr = Vec::new();
+ for i in &atn.states {
+ for tr in i.get_transitions() {
+ match tr.get_serialization_type() {
+ TransitionType::TRANSITION_RULE => {
+ // println!("TRANSITION_RULE");
+ let tr = tr.as_ref().cast::();
+ let target = atn.states.get(tr.get_target()).unwrap();
+
+ let outermost_prec_return = if let ATNStateType::RuleStartState {
+ is_left_recursive: true,
+ ..
+ } = atn
+ .states
+ .get(atn.rule_to_start_state[target.get_rule_index()])
+ .unwrap()
+ .get_state_type()
+ {
+ if tr.precedence == 0 {
+ target.get_rule_index() as isize
+ } else {
+ -1
+ }
+ } else {
+ -1
+ };
+
+ let return_tr = EpsilonTransition {
+ target: tr.follow_state,
+ outermost_precedence_return: outermost_prec_return,
+ };
+ new_tr.push((
+ atn.rule_to_stop_state[target.get_rule_index()],
+ Box::new(return_tr),
+ ));
+ }
+ _ => continue,
+ }
+ }
+ }
+ new_tr
+ .drain(..)
+ .for_each(|(state, tr)| atn.states[state].add_transition(tr));
+
+ for i in 0..atn.states.len() {
+ let atn_state = atn.states.get(i).unwrap();
+ match atn_state.get_state_type() {
+ ATNStateType::DecisionState {
+ state:
+ ATNDecisionState::BlockStartState {
+ end_state: _,
+ en: _,
+ },
+ ..
+ } => {
+
+ // if *end_state == 0 { panic!("invalid state")}
+ // looks like it is never used during recognition
+ // todo missed part
+ }
+ // ATNStateType::DecisionState {state:ATNDecisionState::PlusLoopBack,..} =>{
+ // for tr in atn_state.get_transitions(){
+ // if let ATNStateType::DecisionState {
+ // state:ATNDecisionState::BlockStartState {
+ // en:ATNBlockStart::PlusBlockStart(loopBack),..},..}
+ // = atn.states.get_mut(tr.get_target()).unwrap().get_state_type_mut(){
+ // *loopBack = i;
+ //
+ // }
+ // }
+ // }
+ _x => { /*println!("{:?}",x);*/ }
+ }
+ }
+ }
+
+ fn read_decisions(&self, atn: &mut ATN, _data: &mut dyn Iterator
- ) {
+ let ndecisions = _data.next().unwrap();
+ for i in 0..ndecisions {
+ let s = _data.next().unwrap() as usize;
+ let dec_state: &mut Box = atn.states.get_mut(s).unwrap();
+ atn.decision_to_state.push(s);
+ if let ATNStateType::DecisionState { decision, .. } = dec_state.get_state_type_mut() {
+ *decision = i
+ }
+ }
+ }
+
+ fn read_lexer_actions(&self, atn: &mut ATN, _data: &mut dyn Iterator
- ) {
+ //lexer actions are always supported here
+ let nactions = _data.next().unwrap() as usize;
+
+ for _i in 0..nactions {
+ let action_type = _data.next().unwrap();
+
+ let mut data1 = _data.next().unwrap();
+ if data1 == 0xFFFF {
+ data1 = -1;
+ }
+ let mut data2 = _data.next().unwrap();
+ if data2 == 0xFFFF {
+ data2 = -1;
+ }
+
+ let lexer_action = self.lexer_action_factory(action_type, data1, data2);
+
+ atn.lexer_actions.push(lexer_action);
+ }
+ }
+
+ fn mark_precedence_decisions(&self, _atn: &mut ATN, _data: &mut dyn Iterator
- ) {
+ let mut precedence_states = Vec::new();
+ for state in _atn.states.iter() {
+ if let ATNStateType::DecisionState {
+ state: ATNDecisionState::StarLoopEntry { .. },
+ ..
+ } = state.get_state_type()
+ {
+ if let ATNStateType::RuleStartState {
+ is_left_recursive: true,
+ ..
+ } =
+ _atn.states[_atn.rule_to_start_state[state.get_rule_index()]].get_state_type()
+ {
+ let maybe_loop_end =
+ state.get_transitions().iter().last().unwrap().get_target();
+ let maybe_loop_end = _atn.states[maybe_loop_end].as_ref();
+ if let ATNStateType::LoopEndState(_) = maybe_loop_end.get_state_type() {
+ if maybe_loop_end.has_epsilon_only_transitions() {
+ if let ATNStateType::RuleStopState = _atn.states
+ [maybe_loop_end.get_transitions()[0].get_target()]
+ .get_state_type()
+ {
+ precedence_states.push(state.get_state_number())
+ }
+ }
+ }
+ }
+ }
+ }
+ for st in precedence_states {
+ if let ATNStateType::DecisionState {
+ state:
+ ATNDecisionState::StarLoopEntry {
+ loop_back_state: _,
+ is_precedence,
+ },
+ ..
+ } = _atn.states[st].get_state_type_mut()
+ {
+ *is_precedence = true
+ }
+ }
+ }
+
+ fn verify_atn(&self, _atn: &mut ATN, _data: &mut dyn Iterator
- ) {
+ //TODO
+ }
+
+ // fn check_condition(&self, _condition: bool, _message: String) { unimplemented!() }
+
+ fn edge_factory(
+ &self,
+ _atn: &ATN,
+ type_index: isize,
+ _src: ATNStateRef,
+ target: ATNStateRef,
+ arg1: isize,
+ arg2: isize,
+ arg3: isize,
+ sets: &Vec,
+ ) -> Box {
+ // // let target = atn.states.get
+ // let mut base = BaseTransition {
+ // target: trg,
+ // // is_epsilon: false,
+ // // label: 0,
+ // interval_set: IntervalSet::new_interval_set(),
+ // };
+
+ match type_index {
+ TRANSITION_EPSILON => Box::new(EpsilonTransition {
+ target,
+ outermost_precedence_return: 0,
+ }),
+ TRANSITION_RANGE => Box::new(RangeTransition {
+ target,
+ start: if arg3 != 0 {
+ super::token::TOKEN_EOF
+ } else {
+ arg1
+ },
+ stop: arg2,
+ }),
+ TRANSITION_RULE => {
+ // base.set_target(arg1 as usize);
+ Box::new(RuleTransition {
+ target: arg1 as usize,
+ follow_state: target,
+ rule_index: arg2,
+ precedence: arg3,
+ })
+ }
+ TRANSITION_PREDICATE => Box::new(PredicateTransition {
+ target,
+ is_ctx_dependent: arg3 != 0,
+ rule_index: arg1,
+ pred_index: arg2,
+ }),
+ TRANSITION_ATOM => Box::new(AtomTransition {
+ target,
+ label: if arg3 != 0 { EOF } else { arg1 },
+ }),
+ TRANSITION_ACTION => Box::new(ActionTransition {
+ target,
+ is_ctx_dependent: arg3 != 0,
+ rule_index: arg1,
+ action_index: arg2,
+ pred_index: 0,
+ }),
+ TRANSITION_SET => Box::new(SetTransition {
+ target,
+ set: sets[arg1 as usize].clone(),
+ }),
+ TRANSITION_NOTSET => Box::new(NotSetTransition {
+ target,
+ set: sets[arg1 as usize].clone(),
+ }),
+ TRANSITION_WILDCARD => Box::new(WildcardTransition { target }),
+ TRANSITION_PRECEDENCE => Box::new(PrecedencePredicateTransition {
+ target,
+ precedence: arg1,
+ }),
+ _ => panic!("invalid transition type"),
+ }
+ }
+
+ fn state_factory(
+ &self,
+ type_index: isize,
+ rule_index: isize,
+ state_number: usize,
+ ) -> Box {
+ let mut state = BaseATNState::new_base_atnstate();
+ state.state_number = state_number;
+ state.rule_index = rule_index as usize;
+ state.state_type_id = type_index;
+ state.state_type = match type_index {
+ ATNSTATE_INVALID_TYPE => ATNStateType::InvalidState,
+ ATNSTATE_BASIC => ATNStateType::BasicState,
+ ATNSTATE_RULE_START => ATNStateType::RuleStartState {
+ stop_state: 0,
+ is_left_recursive: false,
+ },
+ ATNSTATE_BLOCK_START => ATNStateType::DecisionState {
+ decision: -1,
+ nongreedy: false,
+ state: ATNDecisionState::BlockStartState {
+ end_state: 0,
+ en: ATNBlockStart::BasicBlockStart,
+ },
+ },
+ ATNSTATE_PLUS_BLOCK_START => ATNStateType::DecisionState {
+ decision: -1,
+ nongreedy: false,
+ state: ATNDecisionState::BlockStartState {
+ end_state: 0,
+ en: ATNBlockStart::PlusBlockStart(0),
+ },
+ },
+ ATNSTATE_STAR_BLOCK_START => ATNStateType::DecisionState {
+ decision: -1,
+ nongreedy: false,
+ state: ATNDecisionState::BlockStartState {
+ end_state: 0,
+ en: ATNBlockStart::StarBlockStart,
+ },
+ },
+ ATNSTATE_TOKEN_START => ATNStateType::DecisionState {
+ decision: -1,
+ nongreedy: false,
+ state: ATNDecisionState::TokenStartState,
+ },
+ ATNSTATE_RULE_STOP => ATNStateType::RuleStopState,
+ ATNSTATE_BLOCK_END => ATNStateType::BlockEndState(0),
+ ATNSTATE_STAR_LOOP_BACK => ATNStateType::StarLoopbackState,
+ ATNSTATE_STAR_LOOP_ENTRY => ATNStateType::DecisionState {
+ decision: -1,
+ nongreedy: false,
+ state: ATNDecisionState::StarLoopEntry {
+ loop_back_state: 0,
+ is_precedence: false,
+ },
+ },
+ ATNSTATE_PLUS_LOOP_BACK => ATNStateType::DecisionState {
+ decision: -1,
+ nongreedy: false,
+ state: ATNDecisionState::PlusLoopBack,
+ },
+ ATNSTATE_LOOP_END => ATNStateType::LoopEndState(0),
+
+ _ => panic!("invalid ATN state type"),
+ };
+ // println!("created state {} {:?}", state_number, state.state_type);
+ Box::new(state)
+ }
+
+ fn lexer_action_factory(&self, action_type: isize, data1: isize, data2: isize) -> LexerAction {
+ match action_type {
+ LEXER_ACTION_TYPE_CHANNEL => LexerChannelAction(data1),
+ LEXER_ACTION_TYPE_CUSTOM => LexerCustomAction {
+ rule_index: data1,
+ action_index: data2,
+ },
+ LEXER_ACTION_TYPE_MODE => LexerModeAction(data1),
+ LEXER_ACTION_TYPE_MORE => LexerMoreAction,
+ LEXER_ACTION_TYPE_POP_MODE => LexerPopModeAction,
+ LEXER_ACTION_TYPE_PUSH_MODE => LexerPushModeAction(data1),
+ LEXER_ACTION_TYPE_SKIP => LexerSkipAction,
+ LEXER_ACTION_TYPE_TYPE => LexerTypeAction(data1),
+ _ => panic!("invalid action type {}", action_type),
+ }
+ }
+}
diff --git a/runtime/Rust/src/atn_simulator.rs b/runtime/Rust/src/atn_simulator.rs
new file mode 100644
index 0000000000..9fae27a60c
--- /dev/null
+++ b/runtime/Rust/src/atn_simulator.rs
@@ -0,0 +1,54 @@
+use std::cell::RefCell;
+use std::fmt::{Debug, Error, Formatter};
+use std::ops::Deref;
+use std::rc::Rc;
+
+use crate::atn::ATN;
+use crate::dfa::DFA;
+use crate::prediction_context::PredictionContextCache;
+
+pub trait IATNSimulator {
+ fn shared_context_cache(&self) -> &PredictionContextCache;
+ fn atn(&self) -> &ATN;
+ fn decision_to_dfa(&self) -> &Vec>;
+}
+
+pub struct BaseATNSimulator {
+ pub atn: Rc,
+ pub shared_context_cache: Rc,
+ pub decision_to_dfa: Rc>>,
+}
+
+impl Debug for BaseATNSimulator {
+ fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+ f.write_str("BaseATNSimulator { .. }")
+ }
+}
+
+impl BaseATNSimulator {
+ pub fn new_base_atnsimulator(
+ atn: Rc,
+ decision_to_dfa: Rc>>,
+ shared_context_cache: Rc,
+ ) -> BaseATNSimulator {
+ BaseATNSimulator {
+ atn,
+ shared_context_cache,
+ decision_to_dfa,
+ }
+ }
+}
+
+impl IATNSimulator for BaseATNSimulator {
+ fn shared_context_cache(&self) -> &PredictionContextCache {
+ self.shared_context_cache.deref()
+ }
+
+ fn atn(&self) -> &ATN {
+ self.atn.as_ref()
+ }
+
+ fn decision_to_dfa(&self) -> &Vec> {
+ self.decision_to_dfa.as_ref()
+ }
+}
diff --git a/runtime/Rust/src/atn_state.rs b/runtime/Rust/src/atn_state.rs
new file mode 100644
index 0000000000..2e6a12508a
--- /dev/null
+++ b/runtime/Rust/src/atn_state.rs
@@ -0,0 +1,443 @@
+use std::fmt::Debug;
+
+use once_cell::sync::OnceCell;
+
+use crate::interval_set::IntervalSet;
+use crate::transition::Transition;
+
+pub(crate) const ATNSTATE_INVALID_TYPE: isize = 0;
+pub(crate) const ATNSTATE_BASIC: isize = 1;
+pub(crate) const ATNSTATE_RULE_START: isize = 2;
+pub(crate) const ATNSTATE_BLOCK_START: isize = 3;
+pub(crate) const ATNSTATE_PLUS_BLOCK_START: isize = 4;
+pub(crate) const ATNSTATE_STAR_BLOCK_START: isize = 5;
+pub(crate) const ATNSTATE_TOKEN_START: isize = 6;
+pub(crate) const ATNSTATE_RULE_STOP: isize = 7;
+pub(crate) const ATNSTATE_BLOCK_END: isize = 8;
+pub(crate) const ATNSTATE_STAR_LOOP_BACK: isize = 9;
+pub(crate) const ATNSTATE_STAR_LOOP_ENTRY: isize = 10;
+pub(crate) const ATNSTATE_PLUS_LOOP_BACK: isize = 11;
+pub(crate) const ATNSTATE_LOOP_END: isize = 12;
+pub(crate) const ATNSTATE_INVALID_STATE_NUMBER: isize = -1;
+
+//might be changed later
+#[doc(hidden)]
+#[derive(Debug, Eq, PartialEq)]
+pub enum ATNStateType {
+ RuleStartState {
+ stop_state: ATNStateRef,
+ is_left_recursive: bool,
+ },
+ RuleStopState,
+ BlockEndState(ATNStateRef),
+ LoopEndState(ATNStateRef),
+ StarLoopbackState,
+ BasicState,
+ DecisionState {
+ decision: isize,
+ nongreedy: bool,
+ state: ATNDecisionState,
+ },
+ InvalidState,
+}
+
+#[doc(hidden)]
+#[derive(Debug, Eq, PartialEq)]
+pub enum ATNDecisionState {
+ StarLoopEntry {
+ loop_back_state: ATNStateRef,
+ is_precedence: bool,
+ },
+ TokenStartState,
+ PlusLoopBack,
+ BlockStartState {
+ end_state: ATNStateRef,
+ en: ATNBlockStart,
+ },
+}
+
+#[doc(hidden)]
+#[derive(Debug, Eq, PartialEq)]
+pub enum ATNBlockStart {
+ BasicBlockStart,
+ StarBlockStart,
+ PlusBlockStart(ATNStateRef),
+}
+
+pub type ATNStateRef = usize;
+
+// todo no need for trait here, it is too slow for hot code
+pub trait ATNState: Sync + Send + Debug {
+ fn has_epsilon_only_transitions(&self) -> bool;
+
+ fn get_rule_index(&self) -> usize;
+ fn set_rule_index(&self, v: usize);
+
+ fn get_next_tokens_within_rule(&self) -> &OnceCell;
+ // fn set_next_token_within_rule(&mut self, v: IntervalSet);
+
+ fn get_state_type(&self) -> &ATNStateType;
+ fn get_state_type_mut(&mut self) -> &mut ATNStateType;
+
+ fn get_state_type_id(&self) -> isize;
+
+ fn get_state_number(&self) -> usize;
+ fn set_state_number(&self, state_number: isize);
+
+ fn get_transitions(&self) -> &Vec>;
+ fn set_transitions(&self, t: Vec>);
+ fn add_transition(&mut self, trans: Box);
+}
+
+#[derive(Debug)]
+pub struct BaseATNState {
+ next_tokens_within_rule: OnceCell,
+
+ // atn: Box,
+ epsilon_only_transitions: bool,
+
+ pub rule_index: usize,
+
+ pub state_number: usize,
+
+ pub state_type_id: isize,
+
+ pub state_type: ATNStateType,
+
+ transitions: Vec>,
+}
+
+impl BaseATNState {
+ pub fn new_base_atnstate() -> BaseATNState {
+ BaseATNState {
+ next_tokens_within_rule: OnceCell::new(),
+ epsilon_only_transitions: false,
+ rule_index: 0,
+ state_number: 0,
+ state_type_id: 0,
+ state_type: ATNStateType::InvalidState,
+ transitions: Vec::new(),
+ }
+ }
+}
+
+impl ATNState for BaseATNState {
+ fn has_epsilon_only_transitions(&self) -> bool {
+ self.epsilon_only_transitions
+ }
+ fn get_rule_index(&self) -> usize {
+ self.rule_index
+ }
+
+ fn set_rule_index(&self, _v: usize) {
+ unimplemented!()
+ }
+
+ fn get_next_tokens_within_rule(&self) -> &OnceCell {
+ &self.next_tokens_within_rule
+ }
+
+ fn get_state_type(&self) -> &ATNStateType {
+ &self.state_type
+ }
+
+ fn get_state_type_mut(&mut self) -> &mut ATNStateType {
+ &mut self.state_type
+ }
+
+ fn get_state_type_id(&self) -> isize {
+ self.state_type_id
+ }
+
+ fn get_state_number(&self) -> usize {
+ self.state_number
+ }
+
+ fn set_state_number(&self, _state_number: isize) {
+ unimplemented!()
+ }
+
+ fn get_transitions(&self) -> &Vec> {
+ &self.transitions
+ }
+
+ fn set_transitions(&self, _t: Vec>) {
+ unimplemented!()
+ }
+
+ fn add_transition(&mut self, trans: Box) {
+ if self.transitions.is_empty() {
+ self.epsilon_only_transitions = trans.is_epsilon()
+ } else {
+ self.epsilon_only_transitions &= trans.is_epsilon()
+ }
+
+ let mut already_present = false;
+ for existing in self.transitions.iter() {
+ if existing.get_target() == trans.get_target() {
+ if existing.get_label().is_some()
+ && trans.get_label().is_some()
+ && existing.get_label() == trans.get_label()
+ {
+ already_present = true;
+ break;
+ } else if existing.is_epsilon() && trans.is_epsilon() {
+ already_present = true;
+ break;
+ }
+ }
+ }
+ if !already_present {
+ self.transitions.push(trans);
+ }
+ }
+}
+//pub struct BasicState {
+// base: BaseATNState,
+//}
+//
+//fn new_basic_state() -> BasicState { unimplemented!() }
+//
+//pub trait DecisionState:ATNState {
+//
+// fn get_decision(&self) -> isize;
+// fn set_decision(&self, b: isize);
+//
+// fn get_non_greedy(&self) -> bool;
+// fn set_non_greedy(&self, b: bool);
+//}
+//
+//pub struct BaseDecisionState {
+// base: BaseATNState,
+// decision: isize,
+// non_greedy: bool,
+//}
+
+//
+//fn new_base_decision_state() -> BaseDecisionState { unimplemented!() }
+//impl DecisionState for BaseDecisionState {
+// fn get_decision(&self) -> isize { unimplemented!() }
+//
+// fn set_decision(&self, b: isize) { unimplemented!() }
+//
+// fn get_non_greedy(&self) -> bool { unimplemented!() }
+//
+// fn set_non_greedy(&self, b: bool) { unimplemented!() }
+//}
+//
+//impl ATNState for BaseDecisionState{
+// fn get_epsilon_only_transitions(&self) -> bool {
+// self.base.get_epsilon_only_transitions()
+// }
+//
+// fn get_rule_index(&self) -> isize {
+// self.base.get_rule_index()
+// }
+//
+// fn set_rule_index(&self, v: isize) {
+// self.base.set_rule_index(v)
+// }
+//
+// fn get_next_token_within_rule(&self) -> IntervalSet {
+// self.base.get_next_token_within_rule()
+// }
+//
+// fn set_next_token_within_rule(&self, v: IntervalSet) {
+// self.base.set_next_token_within_rule(v)
+// }
+//
+// fn get_atn(&self) -> Rc {
+// self.base.get_atn()
+// }
+//
+// fn set_atn(&self, atn: Box) {
+// self.base.set_atn(atn)
+// }
+//
+// fn get_state_type(&self) -> &ATNStateType {
+// self.base.get_state_type()
+// }
+//
+// fn get_state_number(&self) -> isize {
+// self.base.get_state_number()
+// }
+//
+// fn set_state_number(&self, stateNumber: isize) {
+// self.base.set_state_number(stateNumber)
+// }
+//
+// fn get_transitions(&self) -> Vec<&Transition> {
+// self.base.get_transitions()
+// }
+//
+// fn set_transitions(&self, t: Vec>) {
+// self.base.set_transitions(t)
+// }
+//
+// fn add_transition(&self, trans: Box, index: isize) {
+// self.base.add_transition(trans, index)
+// }
+//}
+//pub trait BlockStartState :DecisionState{
+//
+// fn get_end_state(&self) -> &BlockEndState;
+// fn set_end_state(&self, b: Box);
+//}
+//
+//pub struct BaseBlockStartState {
+// base: BaseDecisionState,
+// end_state: Box,
+//}
+//
+//fn new_block_start_state() -> BaseBlockStartState { unimplemented!() }
+//
+//impl BlockStartState for BaseBlockStartState {
+// fn get_end_state(&self) -> &BlockEndState { unimplemented!() }
+//
+// fn set_end_state(&self, b: Box) { unimplemented!() }
+//}
+//
+//impl DecisionState for BaseBlockStartState{
+// fn get_decision(&self) -> isize {
+// self.base.get_decision()
+// }
+//
+// fn set_decision(&self, b: isize) {
+// self.base.set_decision(b)
+// }
+//
+// fn get_non_greedy(&self) -> bool {
+// self.base.get_non_greedy()
+// }
+//
+// fn set_non_greedy(&self, b: bool) {
+// self.base.set_non_greedy(b)
+// }
+//}
+//
+//impl ATNState for BaseBlockStartState{
+// fn get_epsilon_only_transitions(&self) -> bool {
+// self.base.get_epsilon_only_transitions()
+// }
+//
+// fn get_rule_index(&self) -> isize {
+// self.base.get_rule_index()
+// }
+//
+// fn set_rule_index(&self, v: isize) {
+// self.base.set_rule_index(v)
+// }
+//
+// fn get_next_token_within_rule(&self) -> IntervalSet {
+// self.base.get_next_token_within_rule()
+// }
+//
+// fn set_next_token_within_rule(&self, v: IntervalSet) {
+// self.base.set_next_token_within_rule(v)
+// }
+//
+// fn get_atn(&self) -> Rc {
+// self.base.get_atn()
+// }
+//
+// fn set_atn(&self, atn: Box) {
+// self.base.set_atn(atn)
+// }
+//
+// fn get_state_type(&self) -> &ATNStateType {
+// self.base.get_state_type()
+// }
+//
+// fn get_state_number(&self) -> isize {
+// self.base.get_state_number()
+// }
+//
+// fn set_state_number(&self, stateNumber: isize) {
+// self.base.set_state_number(stateNumber)
+// }
+//
+// fn get_transitions(&self) -> Vec<&Transition> {
+// self.base.get_transitions()
+// }
+//
+// fn set_transitions(&self, t: Vec>) {
+// self.base.set_transitions(t)
+// }
+//
+// fn add_transition(&self, trans: Box, index: isize) {
+// self.base.add_transition(trans, index)
+// }
+//}
+//
+//pub struct BasicBlockStartState {
+// base: BaseBlockStartState,
+//}
+//
+//fn new_basic_block_start_state() -> BasicBlockStartState { unimplemented!() }
+//
+//pub struct BlockEndState {
+// base: BaseATNState,
+// start_state: Box,
+//}
+//
+//fn new_block_end_state() -> BlockEndState { unimplemented!() }
+//
+//pub struct RuleStopState {
+// base: BaseATNState,
+//}
+//
+//fn new_rule_stop_state() -> RuleStopState { unimplemented!() }
+//
+//pub struct RuleStartState {
+// base: BaseATNState,
+// stop_state: Box,
+// is_precedence_rule: bool,
+//}
+//
+//fn new_rule_start_state() -> RuleStartState { unimplemented!() }
+//
+//pub struct PlusLoopbackState {
+// base: BaseDecisionState,
+//}
+//
+//fn new_plus_loopback_state() -> PlusLoopbackState { unimplemented!() }
+//
+//pub struct PlusBlockStartState {
+// base: BaseBlockStartState,
+// loop_back_state: Box,
+//}
+//
+//fn new_plus_block_start_state() -> PlusBlockStartState { unimplemented!() }
+//
+//pub struct StarBlockStartState {
+// base: BaseBlockStartState,
+//}
+//
+//fn new_star_block_start_state() -> StarBlockStartState { unimplemented!() }
+//
+//pub struct StarLoopbackState {
+// base: BaseATNState,
+//}
+//
+//fn new_star_loopback_state() -> StarLoopbackState { unimplemented!() }
+//
+//pub struct StarLoopEntryState {
+// base: BaseDecisionState,
+// loop_back_state: Box,
+// precedence_rule_decision: bool,
+//}
+//
+//fn new_star_loop_entry_state() -> StarLoopEntryState { unimplemented!() }
+//
+//pub struct LoopEndState {
+// base: BaseATNState,
+// loop_back_state: Box,
+//}
+//
+//fn new_loop_end_state() -> LoopEndState { unimplemented!() }
+//
+//pub struct TokensStartState {
+// base: BaseDecisionState,
+//}
+//
+//fn new_tokens_start_state() -> TokensStartState { unimplemented!() }
diff --git a/runtime/Rust/src/atn_type.rs b/runtime/Rust/src/atn_type.rs
new file mode 100644
index 0000000000..e379b81f8f
--- /dev/null
+++ b/runtime/Rust/src/atn_type.rs
@@ -0,0 +1,6 @@
+#[doc(hidden)]
+#[derive(Eq, PartialEq, Debug)]
+pub enum ATNType {
+ LEXER = 0,
+ PARSER,
+}
diff --git a/runtime/Rust/src/char_stream.rs b/runtime/Rust/src/char_stream.rs
new file mode 100644
index 0000000000..d93fc38bcc
--- /dev/null
+++ b/runtime/Rust/src/char_stream.rs
@@ -0,0 +1,163 @@
+//! `IntStream` extension for Lexer that allows subslicing of underlying data
+use std::char::REPLACEMENT_CHARACTER;
+use std::convert::TryFrom;
+use std::fmt::Debug;
+use std::ops::{Index, Range, RangeFrom};
+
+use crate::int_stream::IntStream;
+
+/// Provides underlying data for Tokens.
+pub trait CharStream: IntStream {
+ /// Returns underlying data piece, either slice or owned copy.
+ /// Panics if provided indexes are invalid
+ /// Called by parser only on token intervals.
+ /// This fact can be used by custom implementations
+ fn get_text(&self, a: isize, b: isize) -> Data;
+}
+
+/// Trait for input that can be accepted by `InputStream` to be able to provide lexer with data.
+/// Public for implementation reasons.
+pub trait InputData:
+ Index, Output = Self>
+ + Index, Output = Self>
+ + ToOwned
+ + Debug
+ + 'static
+{
+ // fn to_indexed_vec(&self) -> Vec<(u32, u32)>;
+
+ #[doc(hidden)]
+ fn offset(&self, index: isize, item_offset: isize) -> Option;
+
+ #[doc(hidden)]
+ fn item(&self, index: isize) -> Option;
+
+ #[doc(hidden)]
+ fn len(&self) -> usize;
+
+ #[doc(hidden)]
+ fn from_text(text: &str) -> Self::Owned;
+
+ #[doc(hidden)]
+ fn to_display(&self) -> String;
+}
+
+impl + From + TryFrom + Copy + Debug + 'static> InputData for [T]
+where
+ >::Error: Debug,
+{
+ // fn to_indexed_vec(&self) -> Vec<(u32, u32)> {
+ // self.into_iter()
+ // .enumerate()
+ // .map(|(x, &y)| (x as u32, y.into()))
+ // .collect()
+ // }
+
+ #[inline]
+ fn offset(&self, index: isize, item_offset: isize) -> Option {
+ let new_index = index + item_offset;
+ if new_index < 0 {
+ return None; // invalid; no char before first char
+ }
+ if new_index > self.len() as isize {
+ return None;
+ }
+
+ Some(new_index)
+ }
+
+ #[inline]
+ fn item(&self, index: isize) -> Option {
+ self.get(index as usize).map(|&it| it.into() as isize)
+ }
+
+ #[inline]
+ fn len(&self) -> usize {
+ self.len()
+ }
+
+ #[inline]
+ fn from_text(text: &str) -> Self::Owned {
+ text.chars()
+ .map(|it| T::try_from(it as u32).unwrap())
+ .collect()
+ }
+
+ #[inline]
+ // default
+ fn to_display(&self) -> String {
+ self.iter()
+ .map(|x| char::try_from((*x).into()).unwrap_or(REPLACEMENT_CHARACTER))
+ .collect()
+ }
+}
+//
+// impl InputData for [u8] {
+// #[inline]
+// fn to_display(&self) -> String { String::from_utf8_lossy(self).into_owned() }
+// }
+
+// impl InputData for [u16] {
+// }
+//
+// impl InputData for [u32] {
+// #[inline]
+// fn to_display(&self) -> String {
+// self.iter()
+// .map(|x| char::try_from(*x).unwrap_or(REPLACEMENT_CHARACTER))
+// .collect()
+// }
+// }
+
+impl InputData for str {
+ // fn to_indexed_vec(&self) -> Vec<(u32, u32)> {
+ // self.char_indices()
+ // .map(|(i, ch)| (i as u32, ch as u32))
+ // .collect()
+ // }
+
+ #[inline]
+ fn offset(&self, mut index: isize, mut item_offset: isize) -> Option {
+ if item_offset == 0 {
+ return Some(index);
+ }
+ let direction = item_offset.signum();
+
+ while {
+ index += direction;
+ if index < 0 || index > self.len() as isize {
+ return None;
+ }
+ if self.is_char_boundary(index as usize) {
+ item_offset -= direction;
+ }
+ item_offset != 0
+ } {}
+
+ Some(index)
+ }
+
+ #[inline]
+ fn item(&self, index: isize) -> Option {
+ self.get(index as usize..)
+ .and_then(|it| it.chars().next())
+ .map(|it| it as isize)
+ }
+
+ #[inline]
+ fn len(&self) -> usize {
+ self.len()
+ }
+
+ fn from_text(text: &str) -> Self::Owned {
+ text.to_owned()
+ }
+
+ // #[inline]
+ // fn from_text(text: &str) -> Self::Owned { text.to_owned() }
+
+ #[inline]
+ fn to_display(&self) -> String {
+ self.to_string()
+ }
+}
diff --git a/runtime/Rust/src/common_token_stream.rs b/runtime/Rust/src/common_token_stream.rs
new file mode 100644
index 0000000000..e18a3c4a78
--- /dev/null
+++ b/runtime/Rust/src/common_token_stream.rs
@@ -0,0 +1,232 @@
+//! Channel based `TokenStream`
+use std::borrow::Borrow;
+
+use crate::int_stream::{IntStream, IterWrapper, EOF};
+use crate::token::{Token, TOKEN_DEFAULT_CHANNEL, TOKEN_INVALID_TYPE};
+use crate::token_factory::TokenFactory;
+use crate::token_source::TokenSource;
+use crate::token_stream::{TokenStream, UnbufferedTokenStream};
+
+/// Default token stream that skips token that not correspond to current channel.
+#[derive(Debug)]
+pub struct CommonTokenStream<'input, T: TokenSource<'input>> {
+ base: UnbufferedTokenStream<'input, T>,
+ channel: isize,
+}
+
+better_any::tid! { impl<'input,T> TidAble<'input> for CommonTokenStream<'input, T> where T: TokenSource<'input>}
+
+impl<'input, T: TokenSource<'input>> IntStream for CommonTokenStream<'input, T> {
+ #[inline]
+ fn consume(&mut self) {
+ self.base.consume();
+ // self.base.p = self.next_token_on_channel(self.base.p,self.channel);
+ // self.base.current_token_index = self.base.p;
+ let next = self.next_token_on_channel(self.base.p, self.channel, 1);
+ self.base.seek(next);
+ // Ok(())
+ }
+
+ #[inline]
+ fn la(&mut self, i: isize) -> isize {
+ self.lt(i)
+ .map(|t| t.borrow().get_token_type())
+ .unwrap_or(TOKEN_INVALID_TYPE)
+ }
+
+ #[inline(always)]
+ fn mark(&mut self) -> isize {
+ 0
+ }
+
+ #[inline(always)]
+ fn release(&mut self, _marker: isize) {}
+
+ #[inline(always)]
+ fn index(&self) -> isize {
+ self.base.index()
+ }
+
+ #[inline(always)]
+ fn seek(&mut self, index: isize) {
+ self.base.seek(index);
+ }
+
+ #[inline(always)]
+ fn size(&self) -> isize {
+ self.base.size()
+ }
+
+ fn get_source_name(&self) -> String {
+ self.base.get_source_name()
+ }
+}
+
+impl<'input, T: TokenSource<'input>> TokenStream<'input> for CommonTokenStream<'input, T> {
+ type TF = T::TF;
+
+ #[inline(always)]
+ fn lt(&mut self, k: isize) -> Option<&>::Tok> {
+ if k == 1 {
+ return self.base.tokens.get(self.base.p as usize);
+ }
+ if k == 0 {
+ panic!();
+ }
+ if k < 0 {
+ return self.lb(-k);
+ }
+ self.lt_inner(k)
+ }
+
+ #[inline]
+ fn get(&self, index: isize) -> &>::Tok {
+ self.base.get(index)
+ }
+
+ fn get_token_source(&self) -> &dyn TokenSource<'input, TF = Self::TF> {
+ self.base.get_token_source()
+ }
+
+ fn get_text_from_interval(&self, start: isize, stop: isize) -> String {
+ self.base.get_text_from_interval(start, stop)
+ }
+}
+
+impl<'input, T: TokenSource<'input>> CommonTokenStream<'input, T> {
+ /// Creates CommonTokenStream that produces tokens from `TOKEN_DEFAULT_CHANNEL`
+ pub fn new(lexer: T) -> CommonTokenStream<'input, T> {
+ Self::with_channel(lexer, TOKEN_DEFAULT_CHANNEL)
+ }
+
+ /// Creates CommonTokenStream that produces tokens from `channel`
+ pub fn with_channel(lexer: T, channel: isize) -> CommonTokenStream<'input, T> {
+ let mut r = CommonTokenStream {
+ base: UnbufferedTokenStream::new_buffered(lexer),
+ channel,
+ };
+ let i = r.next_token_on_channel(0, channel, 1);
+ r.base.seek(i);
+ r
+ }
+
+ fn lt_inner(&mut self, k: isize) -> Option<&>::Tok> {
+ let mut i = self.base.p;
+ let mut n = 1; // we know tokens[p] is a good one
+ // find k good tokens
+ while n < k {
+ // skip off-channel tokens, but make sure to not look past EOF
+ if self.sync(i + 1) {
+ i = self.next_token_on_channel(i + 1, self.channel, 1);
+ }
+ n += 1;
+ }
+ // if ( i>range ) range = i;
+ return self.base.tokens.get(i as usize);
+ }
+
+ /// Restarts this token stream
+ pub fn reset(&mut self) {
+ self.base.p = 0;
+ self.base.current_token_index = 0;
+ }
+
+ /// Creates iterator over this token stream
+ pub fn iter(&mut self) -> IterWrapper<'_, Self> {
+ IterWrapper(self)
+ }
+
+ fn sync(&mut self, i: isize) -> bool {
+ let need = i - self.size() + 1;
+ if need > 0 {
+ let fetched = self.base.fill(need);
+ return fetched >= need;
+ }
+
+ true
+ }
+ //
+ // fn fetch(&self, n: isize) -> int { unimplemented!() }
+ //
+ // fn get_tokens(&self, start: isize, stop: isize, types: &IntervalSet) -> Vec { unimplemented!() }
+ //
+ // fn lazy_init(&self) { unimplemented!() }
+ //
+ // fn setup(&self) { unimplemented!() }
+ //
+ // fn get_token_source(&self) -> TokenSource { unimplemented!() }
+ //
+ // fn set_token_source(&self, tokenSource: TokenSource) { unimplemented!() }
+
+ //todo make this const generic over direction
+ fn next_token_on_channel(&mut self, mut i: isize, channel: isize, direction: isize) -> isize {
+ self.sync(i);
+ if i >= self.size() {
+ return self.size() - 1;
+ }
+
+ let mut token = self.base.tokens[i as usize].borrow();
+ while token.get_channel() != channel {
+ if token.get_token_type() == EOF || i < 0 {
+ return i;
+ }
+
+ i += direction;
+ self.sync(i);
+ if i >= 0 {
+ token = self.base.tokens[i as usize].borrow();
+ } else {
+ return i;
+ }
+ }
+
+ return i;
+ }
+ //
+ // fn previous_token_on_channel(&self, i: isize, channel: isize) -> int { unimplemented!() }
+ //
+ // fn get_hidden_tokens_to_right(&self, tokenIndex: isize, channel: isize) -> Vec { unimplemented!() }
+ //
+ // fn get_hidden_tokens_to_left(&self, tokenIndex: isize, channel: isize) -> Vec { unimplemented!() }
+ //
+ // fn filter_for_channel(&self, left: isize, right: isize, channel: isize) -> Vec { unimplemented!() }
+ //
+ // fn get_source_name(&self) -> String { unimplemented!() }
+ //
+ // fn get_all_text(&self) -> String { unimplemented!() }
+ //
+ // fn get_text_from_tokens(&self, start: Token, end: Token) -> String { unimplemented!() }
+ //
+ // fn get_text_from_rule_context(&self, interval: RuleContext) -> String { unimplemented!() }
+ //
+ // fn get_text_from_interval(&self, interval: &Interval) -> String { unimplemented!() }
+ //
+ // fn fill(&self) { unimplemented!() }
+ //
+ // fn adjust_seek_index(&self, i: isize) -> int { unimplemented!() }
+
+ fn lb(
+ &mut self,
+ k: isize,
+ ) -> Option<&<>::TF as TokenFactory<'input>>::Tok> {
+ if k == 0 || (self.base.p - k) < 0 {
+ return None;
+ }
+
+ let mut i = self.base.p;
+ let mut n = 1;
+ // find k good tokens looking backwards
+ while n <= k && i > 0 {
+ // skip off-channel tokens
+ i = self.next_token_on_channel(i - 1, self.channel, -1);
+ n += 1;
+ }
+ if i < 0 {
+ return None;
+ }
+
+ return self.base.tokens.get(i as usize);
+ }
+
+ // fn get_number_of_on_channel_tokens(&self) -> int { unimplemented!() }
+}
diff --git a/runtime/Rust/src/context_factory.rs b/runtime/Rust/src/context_factory.rs
new file mode 100644
index 0000000000..e18f4174b8
--- /dev/null
+++ b/runtime/Rust/src/context_factory.rs
@@ -0,0 +1,203 @@
+use std::cell::{Ref, RefCell, RefMut};
+use std::marker::PhantomData;
+use std::ops::{CoerceUnsized, Deref, DerefMut};
+use std::rc::Rc;
+
+use better_any::TidExt;
+use qcell::{TLCell, TLCellOwner};
+use typed_arena::Arena;
+
+use crate::parser_rule_context::ParserRuleContext;
+
+trait ContextFactory<'a, T: ?Sized> {
+ type CtxRef;
+ type Ref: Deref + 'a;
+ type RefMut: DerefMut + 'a;
+
+ fn new(&mut self, inner: T) -> Self::CtxRef
+ where
+ T: Sized;
+
+ fn borrow(&'a self, this: &'a Self::CtxRef) -> Self::Ref;
+ fn borrow_mut(&'a mut self, this: &'a mut Self::CtxRef) -> Self::RefMut;
+}
+
+struct RcFactory;
+
+impl<'a, T: 'a + ?Sized> ContextFactory<'a, T> for RcFactory {
+ type CtxRef = Rc;
+ type Ref = &'a T;
+ type RefMut = &'a mut T;
+
+ fn new(&mut self, inner: T) -> Self::CtxRef
+ where
+ T: Sized,
+ {
+ Rc::new(inner)
+ }
+
+ fn borrow(&'a self, this: &'a Self::CtxRef) -> Self::Ref { &*this }
+
+ fn borrow_mut(&'a mut self, this: &'a mut Self::CtxRef) -> Self::RefMut {
+ unsafe { Rc::get_mut_unchecked(this) }
+ }
+}
+
+struct RefCellFactory {
+ arena: Arena>>,
+}
+
+impl<'a, 'this, T, Dyn> ContextFactory<'a, T> for &'this RefCellFactory
+where
+ T: 'this + 'a + CoerceUnsized + ?Sized,
+ Dyn: 'this + 'a + ?Sized,
+ Box>: CoerceUnsized>>,
+{
+ type CtxRef = &'this RefCell;
+ type Ref = Ref<'a, T>;
+ type RefMut = RefMut<'a, T>;
+
+ fn new(&mut self, inner: T) -> Self::CtxRef
+ where
+ T: Sized,
+ {
+ let val = Box::new(RefCell::new(inner)) as Box>;
+ let res = self.arena.alloc(val).as_mut();
+ unsafe { &*(res as *mut RefCell as *mut RefCell) }
+ }
+
+ fn borrow(&'a self, this: &'a Self::CtxRef) -> Self::Ref { RefCell::borrow(this) }
+
+ fn borrow_mut(&'a mut self, this: &'a mut Self::CtxRef) -> Self::RefMut {
+ RefCell::borrow_mut(this)
+ }
+}
+
+/// index that saves type info to downcast back without checks
+struct Id {
+ idx: usize,
+ phantom: PhantomData>,
+}
+
+struct IdFactory {
+ arena: Vec>,
+}
+
+impl<'a, T, Dyn> ContextFactory<'a, T> for IdFactory
+where
+ T: 'a + CoerceUnsized + ?Sized,
+ Dyn: 'a + ?Sized,
+ Box: CoerceUnsized>,
+{
+ type CtxRef = Id;
+ type Ref = &'a T;
+ type RefMut = &'a mut T;
+
+ fn new(&mut self, inner: T) -> Self::CtxRef
+ where
+ T: Sized,
+ {
+ let b = Box::new(inner);
+ self.arena.push(b as _);
+ Id {
+ idx: self.arena.len() - 1,
+ phantom: Default::default(),
+ }
+ }
+
+ fn borrow(&'a self, this: &'a Self::CtxRef) -> Self::Ref {
+ let this = &*self.arena[this.idx];
+ // safe because we know that T:CoerceUnsized
+ unsafe { std::mem::transmute_copy::<&Dyn, &T>(&this) }
+ }
+
+ fn borrow_mut(&'a mut self, this: &'a mut Self::CtxRef) -> Self::RefMut {
+ let this = &mut *self.arena[this.idx];
+ unsafe { std::mem::transmute_copy::<&mut Dyn, &mut T>(&this) }
+ }
+}
+
+struct Owner;
+
+struct QCellArena {
+ arena: Arena>>,
+ guard: TLCellOwner,
+}
+
+impl<'a, 'this, T, Dyn> ContextFactory<'a, T> for &'this mut QCellArena
+where
+ T: 'a + 'this + CoerceUnsized + ?Sized,
+ Dyn: 'a + 'this + ?Sized,
+ Box>: CoerceUnsized>>,
+{
+ type CtxRef = &'this TLCell;
+ type Ref = &'a T;
+ type RefMut = &'a mut T;
+
+ fn new(&mut self, inner: T) -> Self::CtxRef
+ where
+ T: Sized,
+ {
+ let t = Box::new(self.guard.cell(inner));
+ let r = &**self.arena.alloc(t);
+ unsafe { &*(r as *const _ as *const _) }
+ }
+
+ fn borrow(&'a self, this: &'a Self::CtxRef) -> Self::Ref { self.guard.ro(this) }
+
+ fn borrow_mut(&'a mut self, this: &'a mut Self::CtxRef) -> Self::RefMut { self.guard.rw(this) }
+}
+
+trait Cast {
+ type WrappedT: CoerceUnsized;
+ type WrappedSelf;
+ fn downcast(this: Self::WrappedSelf) -> Self::WrappedT;
+}
+
+impl<'i, T, Y: ?Sized> Cast for Y
+where
+ Y: ParserRuleContext<'i>,
+ T: ParserRuleContext<'i>,
+ Rc: CoerceUnsized>,
+{
+ type WrappedT = Rc;
+ type WrappedSelf = Rc;
+
+ fn downcast(this: Self::WrappedSelf) -> Self::WrappedT { this.downcast_rc().unwrap() }
+}
+
+//
+// trait Downcast<'i, Owner>: CoerceUnsized {
+// type Inner: ParserRuleContext<'i, Ctx = Self::Dyn> + ?Sized;
+// type DynRef;
+// type Dyn;
+// fn downcast<'x>(from: Self::DynRef, owner: Owner) -> Option;
+// }
+//
+// impl<'i, T: ParserRuleContext<'i> + ?Sized, Owner, U> Downcast for Rc
+// where
+// Rc: CoerceUnsized>,
+// {
+// type Inner = T;
+// type DynRef = Rc;
+// type Dyn = T::Ctx;
+//
+// fn downcast<'x>(from: Rc, owner: Owner) -> Option {
+// if from.self_id() == T::id() {
+// Some(unsafe { Rc::from_raw(Rc::into_raw(from) as *const _) })
+// } else {
+// None
+// }
+// }
+// }
+//
+// impl<'i, T: ParserRuleContext<'i> + ?Sized, Owner, U> Downcast for &RefCell
+// where
+// Rc: CoerceUnsized>,
+// {
+// type Inner = T;
+// type DynRef = Rc;
+// type Dyn = T::Ctx;
+//
+// fn downcast<'x>(from: Self::DynRef, owner: Owner) -> Option { unimplemented!() }
+// }
diff --git a/runtime/Rust/src/dfa.rs b/runtime/Rust/src/dfa.rs
new file mode 100644
index 0000000000..0ecf0eb3af
--- /dev/null
+++ b/runtime/Rust/src/dfa.rs
@@ -0,0 +1,168 @@
+use std::collections::HashMap;
+use std::convert::TryFrom;
+
+use std::rc::Rc;
+
+use crate::atn::ATN;
+use crate::atn_config_set::ATNConfigSet;
+use crate::atn_state::{ATNDecisionState, ATNStateRef, ATNStateType};
+use crate::dfa_serializer::DFASerializer;
+use crate::dfa_state::{DFAState, DFAStateRef};
+use crate::vocabulary::Vocabulary;
+
+///Helper trait for scope management and temporary values not living long enough
+pub(crate) trait ScopeExt: Sized {
+ fn convert_with T>(self, f: F) -> T {
+ f(self)
+ }
+ fn run T>(&self, f: F) -> T {
+ f(self)
+ }
+
+ //apply
+ fn modify_with(mut self, f: F) -> Self {
+ f(&mut self);
+ self
+ }
+ //apply_inplace
+ fn apply(&mut self, f: F) -> &mut Self {
+ f(self);
+ self
+ }
+
+ fn drop(self) {}
+}
+
+impl ScopeExt for Any {}
+
+#[derive(Debug)]
+pub struct DFA {
+ /// ATN state from which this DFA creation was started from
+ pub atn_start_state: ATNStateRef,
+
+ pub decision: isize,
+
+ /// Set of all dfa states.
+ pub states: Vec,
+
+ // for faster duplicate search
+ // TODO i think DFAState.edges can contain references to its elements
+ pub(crate) states_map: HashMap>,
+ // states_mu sync.RWMutex
+ /// Initial DFA state
+ pub s0: Option,
+ // s0_mu sync.RWMutex
+ is_precedence_dfa: bool,
+}
+
+impl DFA {
+ pub fn new(atn: Rc, atn_start_state: ATNStateRef, decision: isize) -> DFA {
+ let mut dfa = DFA {
+ atn_start_state,
+ decision,
+ states: Default::default(),
+ // states_map: RefCell::new(HashMap::new()),
+ states_map: Default::default(),
+ s0: Default::default(),
+ is_precedence_dfa: false,
+ };
+
+ // to indicate null
+ dfa.states.push(DFAState::new_dfastate(
+ usize::max_value(),
+ Box::new(ATNConfigSet::new_base_atnconfig_set(true)),
+ ));
+ if let ATNStateType::DecisionState {
+ state:
+ ATNDecisionState::StarLoopEntry {
+ is_precedence: true,
+ ..
+ },
+ ..
+ } = atn.states[atn_start_state].get_state_type()
+ {
+ dfa.is_precedence_dfa = true;
+ let mut precedence_state = DFAState::new_dfastate(
+ dfa.states.len(),
+ Box::new(ATNConfigSet::new_base_atnconfig_set(true)),
+ );
+ precedence_state.edges = vec![];
+ precedence_state.is_accept_state = false;
+ precedence_state.requires_full_context = false;
+
+ dfa.s0 = Some(precedence_state.state_number);
+ dfa.states.push(precedence_state)
+ }
+ dfa
+ }
+
+ pub fn get_precedence_start_state(&self, _precedence: isize) -> Option {
+ if !self.is_precedence_dfa {
+ panic!("dfa is supposed to be precedence here");
+ }
+
+ self.s0.and_then(|s0| {
+ self.states[s0]
+ .edges
+ .get(_precedence as usize)
+ .and_then(|it| match *it {
+ 0 => None,
+ x => Some(x),
+ })
+ })
+ }
+
+ pub fn set_precedence_start_state(&mut self, precedence: isize, _start_state: DFAStateRef) {
+ if !self.is_precedence_dfa {
+ panic!("set_precedence_start_state called for not precedence dfa")
+ }
+
+ if precedence < 0 {
+ return;
+ }
+ let precedence = precedence as usize;
+
+ if let Some(x) = &self.s0 {
+ self.states[*x].edges.apply(|edges| {
+ if edges.len() <= precedence {
+ edges.resize(precedence + 1, 0);
+ }
+ edges[precedence] = _start_state;
+ });
+ }
+ }
+
+ pub fn is_precedence_dfa(&self) -> bool {
+ self.is_precedence_dfa
+ }
+
+ pub fn set_precedence_dfa(&mut self, precedence_dfa: bool) {
+ self.is_precedence_dfa = precedence_dfa
+ }
+
+ pub fn to_string(&self, vocabulary: &dyn Vocabulary) -> String {
+ if self.s0.is_none() {
+ return String::new();
+ }
+
+ return format!(
+ "{}",
+ DFASerializer::new(self, &|x| vocabulary
+ .get_display_name(x as isize - 1)
+ .into_owned(),)
+ );
+ }
+
+ pub fn to_lexer_string(&self) -> String {
+ if self.s0.is_none() {
+ return String::new();
+ }
+ format!(
+ "{}",
+ DFASerializer::new(self, &|x| format!(
+ "'{}'",
+ char::try_from(x as u32).unwrap()
+ ))
+ )
+ }
+}
diff --git a/runtime/Rust/src/dfa_serializer.rs b/runtime/Rust/src/dfa_serializer.rs
new file mode 100644
index 0000000000..dea3a620d6
--- /dev/null
+++ b/runtime/Rust/src/dfa_serializer.rs
@@ -0,0 +1,60 @@
+use std::fmt::{Display, Formatter};
+
+use crate::dfa::DFA;
+use crate::dfa_state::DFAState;
+use crate::lexer_atn_simulator::ERROR_DFA_STATE_REF;
+
+pub struct DFASerializer<'a, 'b> {
+ dfa: &'a DFA,
+ get_edge_label: &'b dyn Fn(usize) -> String,
+}
+
+impl Display for DFASerializer<'_, '_> {
+ fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+ let dfa = &self.dfa.states;
+ for source in dfa.iter() {
+ for (i, edge) in source.edges.iter().copied().enumerate() {
+ if edge != 0 && edge != ERROR_DFA_STATE_REF {
+ let target = &dfa[edge];
+ f.write_fmt(format_args!(
+ "{}-{}->{}\n",
+ self.get_state_string(source),
+ (self.get_edge_label)(i),
+ self.get_state_string(target)
+ ))?;
+ }
+ }
+ }
+ Ok(())
+ }
+}
+
+impl DFASerializer<'_, '_> {
+ pub fn new<'a, 'b>(
+ dfa: &'a DFA,
+ get_edge_label: &'b dyn Fn(usize) -> String,
+ ) -> DFASerializer<'a, 'b> {
+ DFASerializer {
+ dfa,
+ get_edge_label,
+ }
+ }
+
+ fn get_state_string(&self, state: &DFAState) -> String {
+ let mut base_str = format!(
+ "{}s{}{}",
+ if state.is_accept_state { ":" } else { "" },
+ state.state_number - 1,
+ if state.requires_full_context { "^" } else { "" },
+ );
+ if state.is_accept_state {
+ base_str = if !state.predicates.is_empty() {
+ unimplemented!()
+ // format!("{}=>{:?}", base_str, state.predicates)
+ } else {
+ format!("{}=>{}", base_str, state.prediction)
+ };
+ }
+ base_str
+ }
+}
diff --git a/runtime/Rust/src/dfa_state.rs b/runtime/Rust/src/dfa_state.rs
new file mode 100644
index 0000000000..21b156085c
--- /dev/null
+++ b/runtime/Rust/src/dfa_state.rs
@@ -0,0 +1,78 @@
+use std::fmt::{Display, Error, Formatter};
+use std::hash::{Hash, Hasher};
+
+use murmur3::murmur3_32::MurmurHasher;
+
+use crate::atn_config_set::ATNConfigSet;
+use crate::lexer_action_executor::LexerActionExecutor;
+use crate::semantic_context::SemanticContext;
+
+#[derive(Eq, PartialEq, Debug)]
+pub struct PredPrediction {
+ pub(crate) alt: isize,
+ pub(crate) pred: SemanticContext,
+}
+
+impl Display for PredPrediction {
+ fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+ f.write_fmt(format_args!("({},{:?})", self.alt, self.pred))
+ }
+}
+
+//index in DFA.states
+pub type DFAStateRef = usize;
+
+#[derive(Eq, Debug)]
+pub struct DFAState {
+ /// Number of this state in corresponding DFA
+ pub state_number: usize,
+ pub configs: Box,
+ /// - 0 => no edge
+ /// - usize::MAX => error edge
+ /// - _ => actual edge
+ pub edges: Vec,
+ pub is_accept_state: bool,
+
+ pub prediction: isize,
+ pub(crate) lexer_action_executor: Option>,
+ pub requires_full_context: bool,
+ pub predicates: Vec,
+}
+
+impl PartialEq for DFAState {
+ fn eq(&self, other: &Self) -> bool {
+ self.configs == other.configs
+ }
+}
+
+impl Hash for DFAState {
+ fn hash(&self, state: &mut H) {
+ self.configs.hash(state);
+ }
+}
+
+impl DFAState {
+ pub fn default_hash(&self) -> u64 {
+ let mut hasher = MurmurHasher::default();
+ self.hash(&mut hasher);
+ hasher.finish()
+ }
+
+ pub fn new_dfastate(state_number: usize, configs: Box) -> DFAState {
+ DFAState {
+ state_number,
+ configs,
+ // edges: Vec::with_capacity((MAX_DFA_EDGE - MIN_DFA_EDGE + 1) as usize),
+ edges: Vec::new(),
+ is_accept_state: false,
+ prediction: 0,
+ lexer_action_executor: None,
+ requires_full_context: false,
+ predicates: Vec::new(),
+ }
+ }
+
+ // fn get_alt_set(&self) -> &Set { unimplemented!() }
+
+ // fn set_prediction(&self, _v: isize) { unimplemented!() }
+}
diff --git a/runtime/Rust/src/error_listener.rs b/runtime/Rust/src/error_listener.rs
new file mode 100644
index 0000000000..f381c8cc3f
--- /dev/null
+++ b/runtime/Rust/src/error_listener.rs
@@ -0,0 +1,356 @@
+//! Error reporting
+use std::cell::Ref;
+use std::ops::Deref;
+
+use bit_set::BitSet;
+
+use crate::atn_config_set::ATNConfigSet;
+use crate::dfa::DFA;
+use crate::errors::ANTLRError;
+
+use crate::parser::Parser;
+use crate::recognizer::Recognizer;
+
+use crate::token_factory::TokenFactory;
+use std::borrow::Cow;
+use std::fmt::Debug;
+
+/// Describes interface for listening on parser/lexer errors.
+/// Should only listen for errors, for processing/recovering from errors use `ErrorStrategy`
+pub trait ErrorListener<'a, T: Recognizer<'a>> {
+ /// Called when parser/lexer encounter hard error.
+ ///
+ /// The `_error` is not None for all syntax errors except
+ /// when we discover mismatched token errors that we can recover from
+ /// in-line, without returning from the surrounding rule (via the single
+ /// token insertion and deletion mechanism)
+ fn syntax_error(
+ &self,
+ _recognizer: &T,
+ _offending_symbol: Option<&>::Inner>,
+ _line: isize,
+ _column: isize,
+ _msg: &str,
+ _error: Option<&ANTLRError>,
+ ) {
+ }
+
+ /// This method is called by the parser when a full-context prediction
+ /// results in an ambiguity.
+ fn report_ambiguity(
+ &self,
+ _recognizer: &T,
+ _dfa: &DFA,
+ _start_index: isize,
+ _stop_index: isize,
+ _exact: bool,
+ _ambig_alts: &BitSet,
+ _configs: &ATNConfigSet,
+ ) {
+ }
+
+ /// This method is called when an SLL conflict occurs and the parser is about
+ /// to use the full context information to make an LL decision.
+ fn report_attempting_full_context(
+ &self,
+ _recognizer: &T,
+ _dfa: &DFA,
+ _start_index: isize,
+ _stop_index: isize,
+ _conflicting_alts: &BitSet,
+ _configs: &ATNConfigSet,
+ ) {
+ }
+
+ /// This method is called by the parser when a full-context prediction has a
+ /// unique result.
+ fn report_context_sensitivity(
+ &self,
+ _recognizer: &T,
+ _dfa: &DFA,
+ _start_index: isize,
+ _stop_index: isize,
+ _prediction: isize,
+ _configs: &ATNConfigSet,
+ ) {
+ }
+}
+
+impl Debug for Box> {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.debug_struct("Box").finish()
+ }
+}
+
+/// Default error listener that outputs errors to stderr
+#[derive(Debug)]
+pub struct ConsoleErrorListener {}
+
+impl<'a, T: Recognizer<'a>> ErrorListener<'a, T> for ConsoleErrorListener {
+ fn syntax_error(
+ &self,
+ _recognizer: &T,
+ _offending_symbol: Option<&>::Inner>,
+ line: isize,
+ column: isize,
+ msg: &str,
+ _e: Option<&ANTLRError>,
+ ) {
+ eprintln!("line {}:{} {}", line, column, msg);
+ }
+}
+
+// #[derive(Debug)]
+pub(crate) struct ProxyErrorListener<'b, 'a, T> {
+ pub delegates: Ref<'b, Vec>>>,
+}
+
+impl<'b, 'a, T: Recognizer<'a>> ErrorListener<'a, T> for ProxyErrorListener<'b, 'a, T> {
+ fn syntax_error(
+ &self,
+ _recognizer: &T,
+ offending_symbol: Option<&>::Inner>,
+ line: isize,
+ column: isize,
+ msg: &str,
+ e: Option<&ANTLRError>,
+ ) {
+ for listener in self.delegates.deref() {
+ listener.syntax_error(_recognizer, offending_symbol, line, column, msg, e)
+ }
+ }
+
+ fn report_ambiguity(
+ &self,
+ recognizer: &T,
+ dfa: &DFA,
+ start_index: isize,
+ stop_index: isize,
+ exact: bool,
+ ambig_alts: &BitSet,
+ configs: &ATNConfigSet,
+ ) {
+ for listener in self.delegates.deref() {
+ listener.report_ambiguity(
+ recognizer,
+ dfa,
+ start_index,
+ stop_index,
+ exact,
+ ambig_alts,
+ configs,
+ )
+ }
+ }
+
+ fn report_attempting_full_context(
+ &self,
+ recognizer: &T,
+ dfa: &DFA,
+ start_index: isize,
+ stop_index: isize,
+ conflicting_alts: &BitSet,
+ configs: &ATNConfigSet,
+ ) {
+ for listener in self.delegates.deref() {
+ listener.report_attempting_full_context(
+ recognizer,
+ dfa,
+ start_index,
+ stop_index,
+ conflicting_alts,
+ configs,
+ )
+ }
+ }
+
+ fn report_context_sensitivity(
+ &self,
+ recognizer: &T,
+ dfa: &DFA,
+ start_index: isize,
+ stop_index: isize,
+ prediction: isize,
+ configs: &ATNConfigSet,
+ ) {
+ for listener in self.delegates.deref() {
+ listener.report_context_sensitivity(
+ recognizer,
+ dfa,
+ start_index,
+ stop_index,
+ prediction,
+ configs,
+ )
+ }
+ }
+}
+
+/// This implementation of `ErrorListener` can be used to identify
+/// certain potential correctness and performance problems in grammars. "Reports"
+/// are made by calling `Parser::notify_error_listeners` with the appropriate
+/// message.
+///
+/// - Ambiguities: These are cases where more than one path through the
+/// grammar can match the input.
+/// - Weak context sensitivity: These are cases where full-context
+/// prediction resolved an SLL conflict to a unique alternative which equaled the
+/// minimum alternative of the SLL conflict.
+/// - Strong (forced) context sensitivity: These are cases where the
+/// full-context prediction resolved an SLL conflict to a unique alternative,
+/// *and* the minimum alternative of the SLL conflict was found to not be
+/// a truly viable alternative. Two-stage parsing cannot be used for inputs where
+/// this situation occurs.
+#[derive(Debug)]
+pub struct DiagnosticErrorListener {
+ exact_only: bool,
+}
+
+impl DiagnosticErrorListener {
+ /// When `exact_only` is true, only exactly known ambiguities are reported.
+ pub fn new(exact_only: bool) -> Self {
+ Self { exact_only }
+ }
+
+ fn get_decision_description<'a, T: Parser<'a>>(&self, recog: &T, dfa: &DFA) -> String {
+ let decision = dfa.decision;
+ let rule_index = recog.get_atn().states[dfa.atn_start_state].get_rule_index();
+
+ let rule_names = recog.get_rule_names();
+ if let Some(&rule_name) = rule_names.get(rule_index) {
+ format!("{} ({})", decision, rule_name)
+ } else {
+ decision.to_string()
+ }
+ }
+ /// Computes the set of conflicting or ambiguous alternatives from a
+ /// configuration set, if that information was not already provided by the
+ /// parser in `alts`.
+ pub fn get_conflicting_alts<'a>(
+ &self,
+ alts: Option<&'a BitSet>,
+ _configs: &ATNConfigSet,
+ ) -> Cow<'a, BitSet> {
+ match alts {
+ Some(alts) => Cow::Borrowed(alts),
+ None => Cow::Owned(
+ _configs
+ .configs
+ .iter()
+ .map(|config| config.get_alt() as usize)
+ .collect::(),
+ ),
+ }
+ }
+}
+
+impl<'a, T: Parser<'a>> ErrorListener<'a, T> for DiagnosticErrorListener {
+ fn report_ambiguity(
+ &self,
+ recognizer: &T,
+ dfa: &DFA,
+ start_index: isize,
+ stop_index: isize,
+ exact: bool,
+ ambig_alts: &BitSet,
+ _configs: &ATNConfigSet,
+ ) {
+ if self.exact_only && !exact {
+ return;
+ }
+ let msg = format!(
+ "reportAmbiguity d={}: ambigAlts={:?}, input='{}'",
+ self.get_decision_description(recognizer, dfa),
+ ambig_alts,
+ recognizer
+ .get_input_stream()
+ .get_text_from_interval(start_index, stop_index)
+ );
+ recognizer.notify_error_listeners(msg, None, None);
+ }
+
+ fn report_attempting_full_context(
+ &self,
+ recognizer: &T,
+ dfa: &DFA,
+ start_index: isize,
+ stop_index: isize,
+ _conflicting_alts: &BitSet,
+ _configs: &ATNConfigSet,
+ ) {
+ let msg = format!(
+ "reportAttemptingFullContext d={}, input='{}'",
+ self.get_decision_description(recognizer, dfa),
+ recognizer
+ .get_input_stream()
+ .get_text_from_interval(start_index, stop_index)
+ );
+ recognizer.notify_error_listeners(msg, None, None);
+ }
+
+ fn report_context_sensitivity(
+ &self,
+ recognizer: &T,
+ dfa: &DFA,
+ start_index: isize,
+ stop_index: isize,
+ _prediction: isize,
+ _configs: &ATNConfigSet,
+ ) {
+ let msg = format!(
+ "reportContextSensitivity d={}, input='{}'",
+ self.get_decision_description(recognizer, dfa),
+ recognizer
+ .get_input_stream()
+ .get_text_from_interval(start_index, stop_index)
+ );
+ recognizer.notify_error_listeners(msg, None, None);
+ }
+}
+/*
+impl DefaultErrorListener {
+ fn new_default_error_listener() -> * DefaultErrorListener { unimplemented!() }
+
+ fn syntax_error(&self, recognizer: Recognizer, offendingSymbol: interface {
+ }, line: isize, column: isize, msg: String, e: RecognitionError) { unimplemented!() }
+
+ fn report_ambiguity(&self, recognizer: Parser, dfa: * DFA, startIndex: isize, stopIndex: isize, exact: bool, ambigAlts: * BitSet, configs: ATNConfigSet) { unimplemented!() }
+
+ fn report_attempting_full_context(&self, recognizer: Parser, dfa: * DFA, startIndex: isize, stopIndex: isize, conflictingAlts: * BitSet, configs: ATNConfigSet) { unimplemented!() }
+
+ fn report_context_sensitivity(&self, recognizer: Parser, dfa: * DFA, startIndex: isize, stopIndex: isize, prediction: isize, configs: ATNConfigSet) { unimplemented!() }
+
+ pub struct ConsoleErrorListener {
+ base: DefaultErrorListener,
+ }
+
+ fn new_console_error_listener() -> * ConsoleErrorListener { unimplemented!() }
+
+ var ConsoleErrorListenerINSTANCE = NewConsoleErrorListener()
+
+ fn syntax_error(&self, recognizer: Recognizer, offendingSymbol: interface {
+ }, line: isize, column: isize, msg: String, e: RecognitionError) {
+ fmt.Fprintln(os.Stderr, "line " + strconv.Itoa(line) + ":" + strconv.Itoa(column) + " " + msg)
+ }
+
+ pub struct ProxyErrorListener {
+ base: DefaultErrorListener,
+ delegates: Vec < ErrorListener > ,
+ }
+
+ fn new_proxy_error_listener(delegates Vec) -> * ProxyErrorListener { unimplemented!() }
+
+ fn syntax_error(&self, recognizer: Recognizer, offendingSymbol: interface {
+ }, line: isize, column: isize, msg: String, e: RecognitionError) {
+ for _, d: = range p.delegates {
+ d.SyntaxError(recognizer, offendingSymbol, line, column, msg, e)
+ }
+ }
+
+ fn report_ambiguity(&self, recognizer: Parser, dfa: * DFA, startIndex: isize, stopIndex: isize, exact: bool, ambigAlts: * BitSet, configs: ATNConfigSet) { unimplemented!() }
+
+ fn report_attempting_full_context(&self, recognizer: Parser, dfa: * DFA, startIndex: isize, stopIndex: isize, conflictingAlts: * BitSet, configs: ATNConfigSet) { unimplemented!() }
+
+ fn report_context_sensitivity(&self, recognizer: Parser, dfa: * DFA, startIndex: isize, stopIndex: isize, prediction: isize, configs: ATNConfigSet) { unimplemented!() }
+}
+ */
diff --git a/runtime/Rust/src/error_strategy.rs b/runtime/Rust/src/error_strategy.rs
new file mode 100644
index 0000000000..7bf30c9dcc
--- /dev/null
+++ b/runtime/Rust/src/error_strategy.rs
@@ -0,0 +1,643 @@
+//! Error handling and recovery
+use std::borrow::Borrow;
+use std::error::Error;
+use std::fmt;
+use std::fmt::{Display, Formatter};
+use std::ops::{Deref, DerefMut};
+use std::rc::Rc;
+
+use crate::atn_simulator::IATNSimulator;
+use crate::atn_state::*;
+use crate::char_stream::{CharStream, InputData};
+use crate::dfa::ScopeExt;
+use crate::errors::{ANTLRError, FailedPredicateError, InputMisMatchError, NoViableAltError};
+use crate::interval_set::IntervalSet;
+use crate::parser::{Parser, ParserNodeType};
+use crate::parser_rule_context::ParserRuleContext;
+use crate::rule_context::{CustomRuleContext, RuleContext};
+use crate::token::{Token, TOKEN_DEFAULT_CHANNEL, TOKEN_EOF, TOKEN_EPSILON, TOKEN_INVALID_TYPE};
+use crate::token_factory::TokenFactory;
+use crate::transition::RuleTransition;
+use crate::tree::Tree;
+use crate::utils::escape_whitespaces;
+use better_any::{Tid, TidAble};
+
+/// The interface for defining strategies to deal with syntax errors encountered
+/// during a parse by ANTLR-generated parsers. We distinguish between three
+/// different kinds of errors:
+/// - The parser could not figure out which path to take in the ATN (none of
+/// the available alternatives could possibly match)
+/// - The current input does not match what we were looking for
+/// - A predicate evaluated to false
+///
+/// Implementations of this interface should report syntax errors by calling [`Parser::notifyErrorListeners`]
+///
+/// [`Parser::notifyErrorListeners`]: crate::parser::Parser::notifyErrorListeners
+pub trait ErrorStrategy<'a, T: Parser<'a>>: Tid<'a> {
+ ///Reset the error handler state for the specified `recognizer`.
+ fn reset(&mut self, recognizer: &mut T);
+
+ /// 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.
+ ///
+ /// This method handles the consumption of any tokens - the caller should
+ /// **not** call `Parser::consume` after a successful recovery.
+ ///
+ /// Note that the calling code will not report an error if this method
+ /// returns successfully. The error strategy implementation is responsible
+ /// for calling `Parser::notifyErrorListeners` as appropriate.
+ ///
+ /// Returns `ANTLRError` if can't recover from unexpected input symbol
+ fn recover_inline(
+ &mut self,
+ recognizer: &mut T,
+ ) -> Result<>::Tok, 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 recover(&mut self, recognizer: &mut T, e: &ANTLRError) -> 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.
+ ///
+ /// The generated code currently contains calls to `ErrorStrategy::sync` after
+ /// entering the decision state of a closure block ({@code (...)*} or
+ /// {@code (...)+}).
+ fn sync(&mut self, recognizer: &mut T) -> Result<(), ANTLRError>;
+
+ /// 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 in_error_recovery_mode(&mut self, recognizer: &mut T) -> bool;
+
+ /// Report any kind of `ANTLRError`. This method is called by
+ /// the default exception handler generated for a rule method.
+ fn report_error(&mut self, recognizer: &mut T, e: &ANTLRError);
+
+ /// This method is called when the parser successfully matches an input
+ /// symbol.
+ fn report_match(&mut self, recognizer: &mut T);
+}
+//
+// impl<'a, T: Parser<'a>> Default for Box + 'a> {
+// fn default() -> Self { Box::new(DefaultErrorStrategy::new()) }
+// }
+//
+// /// Error strategy trait object if there is a need to change error strategy at runtime
+// /// Supports downcasting.
+// pub type DynHandler<'a, T> = Box + 'a>;
+
+// impl<'a, T: Parser<'a> + TidAble<'a>> TidAble<'a> for Box + 'a> {}
+better_any::tid! { impl<'a, T> TidAble<'a> for Box + 'a> where T: Parser<'a>}
+
+impl<'a, T: Parser<'a> + TidAble<'a>> ErrorStrategy<'a, T> for Box + 'a> {
+ #[inline(always)]
+ fn reset(&mut self, recognizer: &mut T) {
+ self.deref_mut().reset(recognizer)
+ }
+
+ #[inline(always)]
+ fn recover_inline(
+ &mut self,
+ recognizer: &mut T,
+ ) -> Result<