proc-macro-regex 1.1.0

A proc macro regex library
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
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

mod binary_search;
mod lookup_table;

use crate::{character::Character, dfa::Dfa, nfa::START_STATE};
use proc_macro2::{Span, TokenStream};
use quote::{quote, ToTokens};
use std::collections::BTreeSet;
use syn::LitInt;

fn usize_to_lit_int(i: usize) -> LitInt {
    let s = format!("{}", i);
    LitInt::new(&s, Span::call_site())
}

pub(crate) struct DfaToTokens<T>
where
    T: Character,
{
    dfa: Dfa<T>,
    threshold: usize,
    required_states: BTreeSet<usize>,
    is_byte: bool,
}

impl<T> DfaToTokens<T>
where
    T: Character,
{
    /// If `self.end_text` is `true` then only no accept-states have to be implemented.
    /// Because if the state machine reaches an accept-state, then it stops.
    fn get_required_states(dfa: &Dfa<T>) -> BTreeSet<usize> {
        if dfa.end_text {
            dfa.states.clone()
        } else {
            let mut required_states = BTreeSet::new();
            for state in dfa.states.iter() {
                if !dfa.accept_states.contains(state) {
                    required_states.insert(*state);
                }
            }
            required_states
        }
    }

    fn is_byte(dfa: &Dfa<T>) -> bool {
        for (_, transitions) in dfa.transitions.iter() {
            for (ch, _) in transitions.iter() {
                if !ch.is_byte() {
                    return false;
                }
            }
        }
        true
    }

    fn returns_true(&self) -> bool {
        if self.dfa.accept_states.contains(&START_STATE) {
            if self.dfa.end_text {
                !self.dfa.start_text && self.dfa.states.len() == 1
            } else {
                true
            }
        } else {
            false
        }
    }
}

impl<T> DfaToTokens<T>
where
    T: Character + ToTokens + Copy + Into<u32>,
{
    pub(crate) fn new(dfa: Dfa<T>, threshold: usize) -> DfaToTokens<T> {
        let required_states = DfaToTokens::get_required_states(&dfa);
        let is_byte = DfaToTokens::is_byte(&dfa);
        DfaToTokens {
            dfa,
            required_states,
            threshold,
            is_byte,
        }
    }

    fn last_check(&self) -> TokenStream {
        if self.dfa.end_text {
            let accept_states: Vec<LitInt> = self
                .dfa
                .accept_states
                .iter()
                .map(|u| usize_to_lit_int(*u))
                .collect();
            quote! {
                match state {
                    #(#accept_states => true,)*
                    _ => false,
                }
            }
        } else {
            quote! {
                false
            }
        }
    }

    fn for_each(&self) -> TokenStream {
        if let Some(for_each_lookup_table) = self.for_each_lookup_table() {
            for_each_lookup_table
        } else {
            self.for_each_binary_search()
        }
    }

    pub fn get_token_streams(&self) -> TokenStream {
        if self.returns_true() {
            quote! {true}
        } else {
            let for_each = self.for_each();
            let last_check = self.last_check();
            quote! {
                #for_each

                #last_check
            }
        }
    }
}