tuck5 0.2.0

A pragmatic lexer/parser generator
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

pub use crate::*;
pub use sequence::*;
pub use token::*;

#[cfg(test)]
mod tests;

pub trait Transform<T> {
    fn transform<'a>(&self, tokens: Vec<Token<'a, T>>) -> Vec<Token<'a, T>>;
}

pub struct ShallowTransform<T: Clone> {
    pub data: T,
}

impl<T: Clone> Transform<T> for ShallowTransform<T> {
    fn transform<'a>(&self, tokens: Vec<Token<'a, T>>) -> Vec<Token<'a, T>> {
        if let Some(t) = tokens.first() {
            vec![Token {
                root: t.root,
                t_type: TokenType::Leaf(
                    t.content_range().start..tokens.last().unwrap().content_range().end,
                ),
                data: self.data.clone(),
            }]
        } else {
            vec![]
        }
    }
}

pub struct DeepTransform<T: Clone> {
    pub data: T,
}

impl<T: Clone> Transform<T> for DeepTransform<T> {
    fn transform<'a>(&self, tokens: Vec<Token<'a, T>>) -> Vec<Token<'a, T>> {
        if let Some(t) = tokens.first() {
            vec![Token {
                root: t.root,
                t_type: TokenType::Branch(tokens),
                data: self.data.clone(),
            }]
        } else {
            vec![]
        }
    }
}

pub struct RemoveTransform {}

impl<T> Transform<T> for RemoveTransform {
    fn transform<'a>(&self, _: Vec<Token<'a, T>>) -> Vec<Token<'a, T>> {
        vec![]
    }
}

pub fn repeat_until_no_change<T>(funcs: &Vec<&dyn Fn(&mut T) -> bool>, carry_over: &mut T) -> bool {
    let mut changed_at_least_once = false;
    let mut i = 0;
    'outer: while i < funcs.len() {
        let changed = funcs[i](carry_over);
        if changed {
            i = 0;
            changed_at_least_once = true;
            continue 'outer;
        }
        i += 1;
    }
    changed_at_least_once
}