use std::fmt::Debug;
use crate::atn::INVALID_ALT;
use crate::parser_rule_context::{BaseParserRuleContext, ParserRuleContext};
use crate::rule_context::CustomRuleContext;
use crate::token::{CommonToken, Token};
use crate::tree::{ErrorNode, NodeKindType, ParseTreeListener, TerminalNode, TreeNode};
use crate::{cast_unchecked, Arena};
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[repr(u16)]
pub enum InterpreterNodeKind {
Rule,
Terminal,
Error,
}
#[derive(Debug)]
pub struct InterpreterRuleContextExt {
rule_index: usize,
alt_number: i32,
}
impl InterpreterRuleContextExt {
pub(crate) fn new(rule_index: usize) -> Self {
Self {
rule_index,
alt_number: INVALID_ALT,
}
}
}
pub type InterpreterRuleContext<'input, 'arena, Tok = CommonToken<'input>> =
BaseParserRuleContext<'input, 'arena, InterpreterRuleContextExt, InterpreterNodeKind, Tok>;
pub type InterpreterNode<'input, 'arena, Tok = CommonToken<'input>> =
TreeNode<'input, 'arena, InterpreterNodeKind, Tok>;
impl<'input, 'arena, Tok> CustomRuleContext<'input, 'arena, Tok> for InterpreterRuleContextExt
where
'input: 'arena,
Tok: Token + 'input,
{
type NodeKind = InterpreterNodeKind;
fn node_tag() -> InterpreterNodeKind {
InterpreterNodeKind::Rule
}
fn make_node(
arena: &'arena Arena,
ctx: InterpreterRuleContext<'input, 'arena, Tok>,
) -> *mut InterpreterNode<'input, 'arena, Tok> {
arena.alloc_zeroed_node(ctx)
}
fn cast_from<'a>(
node: &'a InterpreterNode<'input, 'arena, Tok>,
) -> Option<&'a InterpreterRuleContext<'input, 'arena, Tok>> {
if node.node_tag() == <Self as CustomRuleContext<'input, 'arena, Tok>>::node_tag() {
Some(cast_unchecked!(node.ctx_ptr() => InterpreterRuleContext<'input, 'arena, Tok>))
} else {
None
}
}
fn cast_from_mut<'a>(
node: &'a mut InterpreterNode<'input, 'arena, Tok>,
) -> Option<&'a mut InterpreterRuleContext<'input, 'arena, Tok>> {
if node.node_tag() == <Self as CustomRuleContext<'input, 'arena, Tok>>::node_tag() {
Some(cast_unchecked!(node.ctx_ptr() => mut InterpreterRuleContext<'input, 'arena, Tok>))
} else {
None
}
}
fn get_rule_index(&self) -> usize {
self.rule_index
}
fn get_alt_number(&self) -> i32 {
self.alt_number
}
fn set_alt_number(&mut self, alt_number: i32) {
self.alt_number = alt_number;
}
}
impl<'arena, Tok> NodeKindType<'arena, Tok> for InterpreterNodeKind
where
Tok: Token + 'arena,
{
type Listener = dyn ParseTreeListener<'arena, InterpreterNodeKind, Tok>;
fn cast_to_ctx<'n, 'input: 'arena>(
node: &'n InterpreterNode<'input, 'arena, Tok>,
) -> &'n dyn ParserRuleContext<'input, 'arena> {
match node.node_tag() {
InterpreterNodeKind::Rule => {
cast_unchecked!(node.ctx_ptr() => InterpreterRuleContext<'input, 'arena, Tok>)
}
InterpreterNodeKind::Terminal => {
cast_unchecked!(node.ctx_ptr() => TerminalNode<'input, 'arena, Tok>)
}
InterpreterNodeKind::Error => {
cast_unchecked!(node.ctx_ptr() => ErrorNode<'input, 'arena, Tok>)
}
}
}
fn cast_to_ctx_mut<'n, 'input: 'arena>(
node: &'n mut InterpreterNode<'input, 'arena, Tok>,
) -> &'n mut dyn ParserRuleContext<'input, 'arena> {
match node.node_tag() {
InterpreterNodeKind::Rule => {
cast_unchecked!(node.ctx_ptr() => mut InterpreterRuleContext<'input, 'arena, Tok>)
}
InterpreterNodeKind::Terminal => {
cast_unchecked!(node.ctx_ptr() => mut TerminalNode<'input, 'arena, Tok>)
}
InterpreterNodeKind::Error => {
cast_unchecked!(node.ctx_ptr() => mut ErrorNode<'input, 'arena, Tok>)
}
}
}
fn set_alt_number<'input: 'arena>(
node: &mut InterpreterNode<'input, 'arena, Tok>,
alt_number: i32,
) {
if let InterpreterNodeKind::Rule = node.node_tag() {
cast_unchecked!(node.ctx_ptr() => mut InterpreterRuleContext<'input, 'arena, Tok>)
.set_alt_number(alt_number)
}
}
fn get_rule_index<'input: 'arena>(node: &InterpreterNode<'input, 'arena, Tok>) -> usize {
match node.node_tag() {
InterpreterNodeKind::Rule => crate::rule_context::RuleContext::get_rule_index(
cast_unchecked!(node.ctx_ptr() => InterpreterRuleContext<'input, 'arena, Tok>),
),
_ => usize::MAX,
}
}
fn get_alt_number<'input: 'arena>(node: &InterpreterNode<'input, 'arena, Tok>) -> i32 {
match node.node_tag() {
InterpreterNodeKind::Rule => crate::rule_context::RuleContext::get_alt_number(
cast_unchecked!(node.ctx_ptr() => InterpreterRuleContext<'input, 'arena, Tok>),
),
_ => INVALID_ALT,
}
}
#[inline]
fn terminal() -> Self {
Self::Terminal
}
#[inline]
fn error() -> Self {
Self::Error
}
#[inline]
fn is_context(&self) -> bool {
matches!(self, Self::Rule)
}
fn enter_rule<'input: 'arena>(
_node: &InterpreterNode<'input, 'arena, Tok>,
_listener: &mut Self::Listener,
) -> Result<(), crate::errors::ANTLRError> {
Ok(())
}
fn exit_rule<'input: 'arena>(
_node: &InterpreterNode<'input, 'arena, Tok>,
_listener: &mut Self::Listener,
) -> Result<(), crate::errors::ANTLRError> {
Ok(())
}
}