lang_pt 0.1.2

A parser tool to generate recursive descent top down parser.
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

use super::FieldTree;

impl<TToken> FieldTree<TToken> {
    pub fn new() -> Self {
        Self {
            token: None,
            children: Vec::new(),
        }
    }

    pub fn insert(&mut self, value: &[u8], token: TToken) -> Result<(), TToken> {
        if value.len() > 0 {
            match self
                .children
                .binary_search_by_key(&value[0], |child| child.0)
            {
                Ok(index) => self.children[index].1.insert(&value[1..], token),
                Err(index) => {
                    let mut field = FieldTree::new();
                    field.insert(&value[1..], token)?;
                    self.children.insert(index, (value[0], field));
                    Ok(())
                }
            }
        } else {
            match self.token.replace(token) {
                Some(t) => Err(t),
                None => Ok(()),
            }
        }
    }
}
impl<TToken: Clone> FieldTree<TToken> {
    pub fn find(&self, code_part: &[u8]) -> Option<(TToken, usize)> {
        let mut current_field = self;
        let mut index = 0;

        loop {
            if code_part.len() > index {
                match current_field
                    .children
                    .binary_search_by_key(&code_part[index], |s| s.0)
                {
                    Ok(i) => {
                        index += 1;
                        current_field = &current_field.children[i].1;
                    }
                    Err(_) => {
                        break current_field.token.as_ref().map(|t| (t.clone(), index));
                    }
                }
            } else {
                break current_field.token.as_ref().map(|t| (t.clone(), index));
            }
        }
    }
}