changed how machines are parsed/represented

src/sim/mod.rs

@@ -0,0 +1,159 @@
+use std::collections::HashMap;
+
+pub mod dfa;
+pub mod dpda;
+pub mod nfa;
+pub mod npda;
+pub mod ntm;
+pub mod tm;
+
+pub trait Get<Idx> {
+    type Output;
+    fn get(&self, idx: Idx) -> Option<&Self::Output>;
+    fn get_mut(&mut self, idx: Idx) -> Option<&mut Self::Output>;
+}
+
+pub trait GetDefault<Idx> {
+    type Output: Default;
+    fn get_or_insert_default(&mut self, idx: Idx) -> &Self::Output;
+    fn get_mut_or_insert_default(&mut self, idx: Idx) -> &mut Self::Output;
+}
+
+macro_rules! index {
+    ($ty: ident, $self:ident, $collection: expr, $index_calc: expr, $index: pat = $index_ty: ty $(, $default: expr)?) => {
+        impl<T> Get<$index_ty> for $ty<T> {
+            type Output = T;
+            fn get(&$self, $index: $index_ty) -> Option<&T>{
+                $collection.get($index_calc)
+            }
+
+            fn get_mut(&mut $self, $index: $index_ty) -> Option<&mut T>{
+                $collection.get_mut($index_calc)
+            }
+        }
+
+        impl<T> std::ops::Index<$index_ty> for $ty<T>{
+            type Output = T;
+
+            fn index(& $self, $index: $index_ty) -> &T{
+                $collection.get($index_calc).unwrap()
+            }
+        }
+
+        impl<T> std::ops::IndexMut<$index_ty> for $ty<T>{
+            fn index_mut(&mut $self, $index: $index_ty) -> &mut T{
+                $collection.get_mut($index_calc).unwrap()
+            }
+        }
+
+        $(
+            impl<T: Default> GetDefault<$index_ty> for $ty<T> {
+                type Output = T;
+                fn get_or_insert_default(&mut $self, $index: $index_ty) -> &T{
+                    $default
+                }
+
+                fn get_mut_or_insert_default(&mut $self, $index: $index_ty) -> &mut T{
+                    $default
+                }
+            }
+        )?
+    };
+}
+
+#[derive(Clone, Debug, Copy, Hash, PartialEq, Eq)]
+pub struct State(u16);
+
+#[derive(Clone, Debug, Copy, Hash, PartialEq, Eq)]
+pub struct Symbol(u16);
+
+#[derive(Clone, Debug)]
+pub struct StateMap<T>(Vec<T>);
+
+index!(StateMap, self, self.0, index.0 as usize, index = State);
+
+impl<T> StateMap<T>{
+    pub fn entries(&self) -> impl Iterator<Item = (State, &T)>{
+        self.0.iter().enumerate().map(|(i, v)|(State(i as u16), v))
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct SymbolMap<T>(Vec<T>);
+
+impl<T> SymbolMap<T>{
+    pub fn entries(&self) -> impl Iterator<Item = (Symbol, &T)>{
+        self.0.iter().enumerate().map(|(i, v)|(Symbol(i as u16), v))
+    }
+}
+
+index!(SymbolMap, self, self.0, index.0 as usize, index = Symbol);
+
+#[derive(Clone, Debug, Default)]
+pub struct StateSymbolMap<T> {
+    map: Vec<T>,
+    max_state: u16,
+}
+
+impl<T> StateSymbolMap<T>{
+    pub fn entries(&self) -> impl Iterator<Item = ((State, Symbol), &T)>{
+        self.map.iter().enumerate().map(|(i, v)|{
+            let state = State((i % self.max_state as usize) as u16);
+            let symbol = Symbol((i / self.max_state as usize) as u16);
+            ((state, symbol), v)
+        })
+    }
+}
+
+index!(
+    StateSymbolMap,
+    self,
+    self.map,
+    state.0 as usize + self.max_state as usize * symbol.0 as usize,
+    (state, symbol) = (State, Symbol)
+);
+index!(
+    StateSymbolMap,
+    self,
+    self.map,
+    state.0 as usize + self.max_state as usize * symbol.0 as usize,
+    (symbol, state) = (Symbol, State)
+);
+
+#[derive(Clone, Debug, Default)]
+pub struct CharMap<T>(HashMap<char, T>);
+
+impl<T> CharMap<T>{
+    pub fn entries(&self) -> impl Iterator<Item = (char, &T)>{
+        self.0.iter().map(|(k, v)|(*k, v))
+    }
+}
+
+index!(
+    CharMap,
+    self,
+    self.0,
+    &char,
+    char = char,
+    self.0.entry(char).or_default()
+);
+
+#[derive(Clone, Debug, Default)]
+pub struct CharEpsilonMap<T>(HashMap<Option<char>, T>);
+
+impl<T> CharEpsilonMap<T>{
+    pub fn entries(&self) -> impl Iterator<Item = (Option<char>, &T)>{
+        self.0.iter().map(|(k, v)|(*k, v))
+    }
+}
+
+index!(
+    CharEpsilonMap,
+    self,
+    self.0,
+    &Some(char),
+    char = char,
+    self.0.entry(Some(char)).or_default()
+);
+index!(CharEpsilonMap, self, self.0, &char, char = Option<char>, self.0.entry(char).or_default());
+