marpa 0.3.0

Safe bindings to the libmarpa parsing engine
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

use crate::lexer::byte_scanner::ByteToken;
use crate::stack::processor::Processor;
use crate::thin::Rule;
use crate::thin::Symbol;
use crate::tree_builder::tree::Handle;
use crate::tree_builder::tree::Node;
use std::collections::HashSet;

#[derive(Default)]
pub struct TreeBuilder {
    token_rules: HashSet<Rule>,
    discard_rules: HashSet<Rule>,
    rules: HashSet<Rule>,
}

impl TreeBuilder {
    pub fn new() -> TreeBuilder {
        Default::default()
    }

    pub fn token(&mut self, rule_id: Rule) {
        self.token_rules.insert(rule_id);
    }

    pub fn is_token(&self, rule_id: Rule) -> bool {
        self.token_rules.contains(&rule_id)
    }

    pub fn rule(&mut self, rule_id: Rule) {
        self.rules.insert(rule_id);
    }

    pub fn is_rule(&self, rule_id: Rule) -> bool {
        self.rules.contains(&rule_id)
    }

    pub fn discard(&mut self, rule_id: Rule) {
        self.discard_rules.insert(rule_id);
    }

    pub fn is_discard(&mut self, rule_id: Rule) -> bool {
        self.discard_rules.contains(&rule_id)
    }
}

impl Processor for TreeBuilder {
    type Tree = Handle<ByteToken>;
    type Token = ByteToken;

    fn proc_rule(&mut self, rule: Rule, children: &[Handle<ByteToken>]) -> Handle<ByteToken> {
        if self.is_token(rule) {
            Node::token(rule, rollup_token(children)).into()
        } else if self.is_rule(rule) {
            Node::rule(rule, rollup_rule(children)).into()
        } else if self.is_discard(rule) {
            Node::Null(0).into()
        } else {
            Node::tree(rule, children).into()
        }
    }

    fn proc_token(&mut self, tok: ByteToken) -> Handle<ByteToken> {
        Node::leaf(tok).into()
    }

    fn proc_null(&mut self, sym: Symbol) -> Handle<ByteToken> {
        Node::null(sym).into()
    }
}

fn rollup_token(children: &[Handle<ByteToken>]) -> Vec<u8> {
    let mut bytes = vec![];
    rollup_token_rec(children, &mut bytes);
    bytes
}

// TODO tco
fn rollup_token_rec(handles: &[Handle<ByteToken>], out: &mut Vec<u8>) {
    for child in handles.iter() {
        match *child.borrow() {
            Node::Leaf(tok) => out.push(*tok),
            Node::Null(_) => {}
            Node::Tree(_, ref chs) => rollup_token_rec(chs, out),
            Node::Rule(_, _) => panic!("cannot rollup Rule into Token - this is an internal bug."),
            Node::Token(_, _) => panic!("cannot rollup Token into Token - this is an internal bug."),
        }
    }
}

fn rollup_rule(children: &[Handle<ByteToken>]) -> Vec<Handle<ByteToken>> {
    let mut new_children = vec![];
    rollup_rule_rec(children, &mut new_children);
    new_children
}

// TODO tco
fn rollup_rule_rec(handles: &[Handle<ByteToken>], out: &mut Vec<Handle<ByteToken>>) {
    for child in handles.iter() {
        match *child.borrow() {
            Node::Token(_, _) => out.push(child.clone()),
            Node::Rule(_, _) => out.push(child.clone()),
            Node::Null(_) => {}
            Node::Tree(_, ref chs) => rollup_rule_rec(chs, out),
            Node::Leaf(_) => panic!("cannot rollup Leaf into Rule - this is an internal bug."),
        }
    }
}