dbt-antlr4 1.2.1

Dbt fork of ANTLR4 runtime for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use std::cell::OnceCell;
use std::fmt::{Debug, Error, Formatter};

use crate::atn::ATN;
use crate::atn_config_set::ConfigSet;
use crate::dfa::DFA;
use crate::prediction_context::PredictionContextCache;
use crate::Arena;

pub trait IATNSimulator<'sim, CS>
where
    CS: ConfigSet<'sim>,
{
    fn atn(&self) -> &'static ATN;
    fn shared_context_cache(&self) -> &'sim PredictionContextCache<'sim>;
    fn decision_to_dfa(&self, decision: usize) -> Option<&'sim DFA<'sim, CS>>;
    fn sim_arena(&self) -> &'sim bumpalo::Bump;
}

pub struct BaseATNSimulator<'sim, CS>
where
    CS: ConfigSet<'sim> + 'sim,
{
    pub atn: &'static ATN,
    // (True) owner of the 'sim lifetime:
    arena: *const bumpalo::Bump,
    // Memory managed by arena:
    shared_context_cache: &'sim PredictionContextCache<'sim>,
    // Memory managed by arena:
    decision_to_dfa: &'sim [OnceCell<DFA<'sim, CS>>],
}

impl<'sim, CS: ConfigSet<'sim>> Debug for BaseATNSimulator<'sim, CS> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        f.write_str("BaseATNSimulator { .. }")
    }
}

impl<'sim, CS: ConfigSet<'sim>> BaseATNSimulator<'sim, CS> {
    pub fn new_base_atnsimulator(
        atn: &'static ATN,
        arena: &'sim Arena,
    ) -> BaseATNSimulator<'sim, CS> {
        let (arena_ref, raw_arena) = unsafe { arena.make_sim_arena() };
        let shared_context_cache = arena_ref.alloc(PredictionContextCache::new(arena_ref));
        let decision_to_dfa =
            arena_ref.alloc_slice_fill_with(atn.decision_to_state.len(), |_| OnceCell::new());

        BaseATNSimulator {
            atn,
            arena: raw_arena,
            shared_context_cache,
            decision_to_dfa,
        }
    }
}

impl<'sim, CS: ConfigSet<'sim>> IATNSimulator<'sim, CS> for BaseATNSimulator<'sim, CS> {
    fn atn(&self) -> &'static ATN {
        self.atn
    }

    fn shared_context_cache(&self) -> &'sim PredictionContextCache<'sim> {
        self.shared_context_cache
    }

    fn decision_to_dfa(&self, decision: usize) -> Option<&'sim DFA<'sim, CS>> {
        self.decision_to_dfa.get(decision).map(|cell| {
            cell.get_or_init(|| {
                DFA::<CS>::new(
                    self.atn(),
                    self.sim_arena(),
                    self.atn.get_decision_state(decision as i32),
                    decision as i32,
                )
            })
        })
    }

    fn sim_arena(&self) -> &'sim bumpalo::Bump {
        // SAFETY: previously leaked by Box::into_raw in the constructor, and
        // not modified thereafter:
        unsafe { &*self.arena }
    }
}

impl<'sim, CS: ConfigSet<'sim>> Drop for BaseATNSimulator<'sim, CS> {
    fn drop(&mut self) {
        // SAFETY: previously leaked by Box::into_raw in the constructor, and
        // not modified thereafter:
        let arena = unsafe { Box::from_raw(self.arena as *mut bumpalo::Bump) };
        drop(arena);
    }
}