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
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::lexer::token::Token;
use crate::thin::Rule;
use crate::thin::Symbol;
use std::cell::RefCell;
use std::fmt;
use std::ops::Deref;
use std::rc::Rc;

#[derive(Clone, Default, Debug)]
pub struct Handle<T: Token>(Rc<RefCell<Node<T>>>);

#[derive(Debug)]
pub enum Node<T>
where
    T: Token,
{
    Rule(Rule, Vec<Handle<T>>),
    Tree(Rule, Vec<Handle<T>>),
    Token(Rule, Vec<u8>),
    Leaf(T),
    Null(Symbol),
}

impl<T: Token> fmt::Display for Node<T>
where
    T: fmt::Display,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Node::Tree(ref rule, ref children) => {
                write!(f, "Tree({},", rule)?;
                for child in children {
                    write!(f, " {}", child)?;
                }
                write!(f, ")")?;
            }
            Node::Rule(ref rule, ref children) => {
                write!(f, "Rule({},", rule)?;
                for child in children {
                    write!(f, " {}", child)?;
                }
                write!(f, ")")?;
            }
            Node::Token(ty, ref val) => {
                write!(f, "Token({}, ", ty)?;
                match ::std::str::from_utf8(&val) {
                    Ok(s) => write!(f, "\"{}\"", s)?,
                    Err(_) => write!(f, "{:?}", val)?,
                }
                write!(f, ")")?;
            }
            Node::Leaf(ref tok) => {
                write!(f, "Leaf({})", tok)?;
            }
            Node::Null(sym) => {
                write!(f, "Null({})", sym)?;
            }
        }
        Ok(())
    }
}

impl<T: Token> fmt::Display for Handle<T>
where
    T: fmt::Display,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", *self.borrow())
    }
}

impl<T: Token> Node<T> {
    pub fn token<V: Into<Vec<u8>>>(tok: Symbol, val: V) -> Node<T> {
        Node::Token(tok, val.into())
    }

    pub fn leaf(tok: T) -> Node<T> {
        Node::Leaf(tok)
    }

    pub fn rule<V: Into<Vec<Handle<T>>>>(rule: Rule, children: V) -> Node<T>
    where
        T: Clone,
    {
        Node::Rule(rule, children.into())
    }

    pub fn tree<V: Into<Vec<Handle<T>>>>(rule: Rule, children: V) -> Node<T>
    where
        T: Clone,
    {
        Node::Tree(rule, children.into())
    }

    pub fn null(sym: Symbol) -> Node<T> {
        Node::Null(sym)
    }
}

impl<T: Token> Default for Node<T>
where
    T: Default,
{
    fn default() -> Node<T> {
        Node::Null(-1)
    }
}

impl<T: Token> Deref for Handle<T> {
    type Target = Rc<RefCell<Node<T>>>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T: Token> From<Node<T>> for Handle<T> {
    fn from(other: Node<T>) -> Handle<T> {
        Handle(Rc::new(RefCell::new(other)))
    }
}