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

use std::ops::AddAssign;
use uuid::Uuid;
use regular_expression_bootstrap::StateGenerator;

#[macro_use]
mod util;
mod lexer;

pub use crate::lexer::{
    Token,
    Lexer
};

#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TokenState<T> {
    uuid: u128,
    sequence_number: u128,
    token_kind: Option<T>,
}

impl<T: Clone> TokenState<T> {
    fn new(token_kind: Option<T>) -> TokenState<T> {
        TokenState { uuid: Uuid::new_v4().as_u128(), sequence_number: 0, token_kind }
    }

    fn token_kind(&self) -> &Option<T> {
        &self.token_kind
    }

    fn clear_token_kind(&mut self) {
        self.token_kind = None;
    }
}

impl<T> AddAssign<u128> for TokenState<T> {
    fn add_assign(&mut self, other: u128) {
        self.sequence_number += other;
    }
}

struct TokenStateGenerator<T> {
    token_state: TokenState<T>,
    final_enabled: bool,
}

impl<T: Clone> TokenStateGenerator<T> {
    pub fn new(token: Option<T>) -> TokenStateGenerator<T> {
        TokenStateGenerator { token_state: TokenState::new(token), final_enabled: true }
    }

    fn next_final_enabled(&mut self) -> TokenState<T> {
        let next = self.token_state.clone();
        self.token_state += 1;
        next
    }

    fn next_final_disabled(&mut self) -> TokenState<T> {
        let mut next = self.token_state.clone();
        self.token_state += 1;
        next.clear_token_kind();
        next
    }
}

impl<T: Clone> StateGenerator for TokenStateGenerator<T> {
    type State = TokenState<T>;

    fn next_initial(&mut self) -> TokenState<T> {
        let mut next = self.token_state.clone();
        self.token_state += 1;
        next.clear_token_kind();
        next
    }

    fn next_final(&mut self) -> TokenState<T> {
        if self.final_enabled {
            self.next_final_enabled()
        } else {
            self.next_final_disabled()
        }
    }

    fn disable_final(&mut self) -> &mut TokenStateGenerator<T> {
        self.final_enabled = false;
        self
    }

    fn enable_final(&mut self) -> &mut TokenStateGenerator<T> {
        self.final_enabled = true;
        self
    }
}