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
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

use std::collections::HashMap;
use std::convert::TryFrom;
use std::ops::Deref;
use std::sync::{Arc, RwLock};

use crate::atn::ATN;
use crate::atn_config_set::ATNConfigSet;
use crate::atn_state::{ATNDecisionState, ATNState, 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, F: FnOnce(Self) -> T>(self, f: F) -> T {
        f(self)
    }
    fn run<T, F: FnOnce(&Self) -> T>(&self, f: F) -> T {
        f(self)
    }

    //apply
    fn modify_with<F: FnOnce(&mut Self)>(mut self, f: F) -> Self {
        f(&mut self);
        self
    }
    //apply_inplace
    fn apply<F: FnOnce(&mut Self)>(&mut self, f: F) -> &mut Self {
        f(self);
        self
    }

    fn drop(self) {}
}

impl<Any: Sized> ScopeExt for Any {}


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: RwLock<Vec<DFAState>>,

    // for faster duplicate search
    // TODO i think DFAState.edges can contain references to its elements
    pub(crate) states_map: RwLock<HashMap</*DFAState hash*/ u64, Vec<DFAStateRef>>>,
    //    states_mu sync.RWMutex
    /// Initial DFA state
    pub s0: RwLock<Option<DFAStateRef>>,
    //    s0_mu sync.RWMutex
    is_precedence_dfa: bool,
}

impl DFA {
    pub fn new(atn: Arc<ATN>, atn_start_state: ATNStateRef, decision: isize) -> DFA {
        let mut dfa = DFA {
            atn_start_state,
            decision,
            states: RwLock::new(Vec::new()),
            //            states_map: RwLock::new(HashMap::new()),
            states_map: RwLock::new(HashMap::new()),
            s0: RwLock::new(None),
            is_precedence_dfa: false,
        };

        // to indicate null
        dfa.states.write().unwrap().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.read().unwrap().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 = RwLock::new(Some(precedence_state.state_number));
            dfa.states.write().unwrap().push(precedence_state)
        }
        dfa
    }

    pub fn get_precedence_start_state(&self, _precedence: isize) -> Option<DFAStateRef> {
        if !self.is_precedence_dfa {
            panic!("dfa is supposed to be precedence here");
        }

        self.s0.read().unwrap()
            .and_then(|s0| {
                self.states
                    .read().unwrap()[s0]
                    .edges
                    .get(_precedence as usize)
                    .copied()
                    .and_then(|it| match it {
                        0 => None,
                        x => Some(x)
                    })
            }
            )
    }

    pub fn set_precedence_start_state(&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.write().unwrap().deref() {
            self.states
                .write().unwrap()[*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
    }

    fn num_states(&self) -> isize {
        unimplemented!()
    }

    pub fn to_string(&self, vocabulary: &dyn Vocabulary) -> String {
        if self.s0.read().unwrap().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.read().unwrap().is_none() { return String::new(); }
        format!(
            "{}",
            DFASerializer::new(self, &|x| format!(
                "'{}'",
                char::try_from(x as u32).unwrap()
            ))
        )
    }
}